diff --git a/.mailmap b/.mailmap index 6a9362f6e4cf3..73ebed0cc7cd6 100644 --- a/.mailmap +++ b/.mailmap @@ -1,13 +1,14 @@  AbubakerB # Abubaker Bashir Alexander # Alexander Kuvaev +Aluan Haddad Adam Freidin Adam Freidin Adi Dahiya Adi Dahiya Ahmad Farid ahmad-farid Alexander Rusakov Alex Eagle Anatoly Ressin -Anders Hejlsberg unknown unknown +Anders Hejlsberg unknown unknown Anders Hejlsberg about-code # Andreas Martin Andrej Baran Andrew Ochsner @@ -24,6 +25,7 @@ Basarat Ali Syed Basarat Syed basa Bill Ticehurst Bill Ticehurst Ben Duffield Ben Mosher +Benjamin Bock Blake Embrey Bowden Kelly Brett Mayen @@ -49,6 +51,7 @@ Dirk Holtwick Dom Chen Doug Ilijev Erik Edrosa +Erik McClenney erictsangx # Eric Tsang Ethan Rubio Evan Martin @@ -68,13 +71,18 @@ Guillaume Salles Guy Bedford guybedford Harald Niesche Homa Wong +Hendrik Liebau Iain Monro +IgorNovozhilov # Igor Novozhilov Ingvar Stepanyan impinball # Isiah Meadows +Iwata Hidetaka Ivo Gabe de Wolff Jakub Młokosiewicz James Whitney +James Henry Jason Freeman Jason Freeman +Jason Jarrett Jason Killian Jason Ramsay jramsay Jed Mao @@ -89,6 +97,7 @@ Jonathan Toland Jesse Schalken Joel Day Josh Abernathy joshaber +Josh Goldberg Josh Kalderimis Josh Soref Juan Luis Boya García @@ -107,20 +116,26 @@ Keith Mashinter kmashint Ken Howard Kevin Lang kimamula # Kenji Imamula +Kitson Kelly Klaus Meinhardt Kyle Kelley Lorant Pinter Lucien Greathouse Lukas Elmer Lukas Elmer +Magnus Hiie Martin Vseticka Martin Všeticka MartyIX gcnew # Marin Marinov vvakame # Masahiro Wakame -Matt McCutchen +Matt McCutchen Matt McCutchen +Matt Bierner MANISH-GIRI # Manish Giri Max Deepfield Micah Zoltu Michael +Mike Busyrev +Mine Starks Mine Starks Mohamed Hegazy +ncoley # Natalie Coley Nathan Shively-Sanders Nathan Yee Nima Zahedi @@ -143,12 +158,14 @@ Rado Kirov Ron Buckton Ron Buckton rbuckton Rostislav Galimsky Richard Knoll Richard Knoll +Richard Karmazín Rowan Wyborn Ryan Cavanaugh Ryan Cavanaugh Ryan Cavanaugh Ryohei Ikegami Sarangan Rajamanickam Sébastien Arod Sergey Shandar +chico # Sergey Rubanov Sheetal Nandi Shengping Zhong shyyko.serhiy@gmail.com # Shyyko Serhiy @@ -156,6 +173,7 @@ Sam El-Husseini Simon Hürlimann Slawomir Sadziak Solal Pirelli +Soo Jae Hwang Stan Thomas Stanislav Sysoev Steve Lucco steveluc @@ -173,6 +191,7 @@ Torben Fitschen TruongSinh Tran-Nguyen vilicvane # Vilic Vane Vladimir Matveev vladima v2m +Vadi Taslim Wesley Wigham Wesley Wigham York Yao york yao yaoyao Yuichi Nukiyama YuichiNukiyama @@ -199,6 +218,7 @@ Aliaksandr Radzivanovich BuildTools # Franklin Tse ChogyDan # Daniel Hollocher Daniel Rosenwasser Daniel Rosenwasser +DLehenbauer # Daniel Lehenbauer David Kmenta E020873 # Nicolas Henry Elisée Maurer @@ -225,4 +245,7 @@ Viktor Zozulyak rix # Richard Sentino rohitverma007 # Rohit Verma rdosanjh # Raj Dosanjh -gdh1995 # Dahan Gong \ No newline at end of file +gdh1995 # Dahan Gong +cedvdb # @cedvdb +kpreisser # K. Preißer +e-cloud # @e-cloud \ No newline at end of file diff --git a/AUTHORS.md b/AUTHORS.md index 196f5e84542d2..4772d5371fad1 100644 --- a/AUTHORS.md +++ b/AUTHORS.md @@ -10,6 +10,7 @@ TypeScript is authored by: * Alexander Rusakov * Ali Sabzevari * Aliaksandr Radzivanovich +* Aluan Haddad * Anatoly Ressin * Anders Hejlsberg * Andreas Martin @@ -29,6 +30,7 @@ TypeScript is authored by: * Basarat Ali Syed * Ben Duffield * Ben Mosher +* Benjamin Bock * Bill Ticehurst * Blake Embrey * @bootstraponline @@ -36,6 +38,7 @@ TypeScript is authored by: * Brett Mayen * Bryan Forbes * Caitlin Potter +* @cedvdb * Charly POLY * Chris Bubernak * Christophe Vidal @@ -49,6 +52,7 @@ TypeScript is authored by: * Dan Corder * Dan Quirk * Daniel Hollocher +* Daniel Lehenbauer * Daniel Rosenwasser * David Kmenta * David Li @@ -60,10 +64,12 @@ TypeScript is authored by: * Dirk Holtwick * Dom Chen * Doug Ilijev +* @e-cloud * Elisée Maurer * Emilio García-Pumarino * Eric Tsang * Erik Edrosa +* Erik McClenney * Ethan Resnick * Ethan Rubio * Evan Martin @@ -84,15 +90,20 @@ TypeScript is authored by: * Guillaume Salles * Guy Bedford * Harald Niesche +* Hendrik Liebau * Herrington Darkholme * Homa Wong * Iain Monro +* Igor Novozhilov * Ingvar Stepanyan * Isiah Meadows * Ivo Gabe de Wolff +* Iwata Hidetaka * Jakub Młokosiewicz +* James Henry * James Whitney * Jason Freeman +* Jason Jarrett * Jason Killian * Jason Ramsay * JBerger @@ -110,29 +121,34 @@ TypeScript is authored by: * Jonathan Turner * Jonathon Smith * Josh Abernathy +* Josh Goldberg * Josh Kalderimis * Josh Soref * Juan Luis Boya García * Julian Williams * Justin Bay * Justin Johansson +* K. Preißer * Kagami Sascha Rosylight * Kanchalai Tanglertsampan * Keith Mashinter * Ken Howard * Kenji Imamula * Kevin Lang +* Kitson Kelly * Klaus Meinhardt * Kyle Kelley * Kārlis Gaņģis * Lorant Pinter * Lucien Greathouse * Lukas Elmer +* Magnus Hiie * Manish Giri * Marin Marinov * Marius Schulz * Martin Vseticka * Masahiro Wakame +* Matt Bierner * Matt McCutchen * Mattias Buelens * Mattias Buelens @@ -140,8 +156,11 @@ TypeScript is authored by: * Micah Zoltu * Michael * Michael Bromley +* Mike Busyrev +* Mine Starks * Mohamed Hegazy * Myles Megyesi +* Natalie Coley * Nathan Shively-Sanders * Nathan Yee * Nicolas Henry @@ -167,6 +186,7 @@ TypeScript is authored by: * Punya Biswal * Rado Kirov * Raj Dosanjh +* Richard Karmazín * Richard Knoll * Richard Sentino * Robert Coie @@ -178,6 +198,7 @@ TypeScript is authored by: * Ryohei Ikegami * Sam El-Husseini * Sarangan Rajamanickam +* Sergey Rubanov * Sergey Shandar * Sheetal Nandi * Shengping Zhong @@ -185,6 +206,7 @@ TypeScript is authored by: * Simon Hürlimann * Slawomir Sadziak * Solal Pirelli +* Soo Jae Hwang * Stan Thomas * Stanislav Sysoev * Steve Lucco @@ -204,6 +226,7 @@ TypeScript is authored by: * Tomas Grubliauskas * Torben Fitschen * TruongSinh Tran-Nguyen +* Vadi Taslim * Vidar Tonaas Fauske * Viktor Zozulyak * Vilic Vane diff --git a/Gulpfile.ts b/Gulpfile.ts index 022606e133b01..7b8c8f015a760 100644 --- a/Gulpfile.ts +++ b/Gulpfile.ts @@ -175,7 +175,7 @@ for (const i in libraryTargets) { const sources = [copyright].concat(entry.sources.map(function(s) { return path.join(libraryDirectory, s); })); - gulp.task(target, false, [], function() { + gulp.task(target, /*help*/ false, [], function() { return gulp.src(sources) .pipe(newer(target)) .pipe(concat(target, { newLine: "\n\n" })) @@ -275,7 +275,7 @@ function getCompilerSettings(base: tsc.Settings, useBuiltCompiler?: boolean): ts return copy; } -gulp.task(configureNightlyJs, false, [], () => { +gulp.task(configureNightlyJs, /*help*/ false, [], () => { const settings: tsc.Settings = { declaration: false, removeComments: true, @@ -304,7 +304,7 @@ const importDefinitelyTypedTestsDirectory = path.join(scriptsDirectory, "importD const importDefinitelyTypedTestsJs = path.join(importDefinitelyTypedTestsDirectory, "importDefinitelyTypedTests.js"); const importDefinitelyTypedTestsTs = path.join(importDefinitelyTypedTestsDirectory, "importDefinitelyTypedTests.ts"); -gulp.task(importDefinitelyTypedTestsJs, false, [], () => { +gulp.task(importDefinitelyTypedTestsJs, /*help*/ false, [], () => { const settings: tsc.Settings = getCompilerSettings({ declaration: false, removeComments: true, @@ -335,7 +335,7 @@ const generatedDiagnosticMessagesJSON = path.join(compilerDirectory, "diagnostic const builtGeneratedDiagnosticMessagesJSON = path.join(builtLocalDirectory, "diagnosticMessages.generated.json"); // processDiagnosticMessages script -gulp.task(processDiagnosticMessagesJs, false, [], () => { +gulp.task(processDiagnosticMessagesJs, /*help*/ false, [], () => { const settings: tsc.Settings = getCompilerSettings({ target: "es5", declaration: false, @@ -383,7 +383,7 @@ function prependCopyright(outputCopyright: boolean = !useDebugMode) { return insert.prepend(outputCopyright ? (copyrightContent || (copyrightContent = fs.readFileSync(copyright).toString())) : ""); } -gulp.task(builtLocalCompiler, false, [servicesFile], () => { +gulp.task(builtLocalCompiler, /*help*/ false, [servicesFile], () => { const localCompilerProject = tsc.createProject("src/compiler/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true)); return localCompilerProject.src() .pipe(newer(builtLocalCompiler)) @@ -394,7 +394,7 @@ gulp.task(builtLocalCompiler, false, [servicesFile], () => { .pipe(gulp.dest("src/compiler")); }); -gulp.task(servicesFile, false, ["lib", "generate-diagnostics"], () => { +gulp.task(servicesFile, /*help*/ false, ["lib", "generate-diagnostics"], () => { const servicesProject = tsc.createProject("src/services/tsconfig.json", getCompilerSettings({ removeComments: false }, /*useBuiltCompiler*/false)); const {js, dts} = servicesProject.src() .pipe(newer(servicesFile)) @@ -428,7 +428,7 @@ gulp.task(servicesFile, false, ["lib", "generate-diagnostics"], () => { // cancellationToken.js const cancellationTokenJs = path.join(builtLocalDirectory, "cancellationToken.js"); -gulp.task(cancellationTokenJs, false, [servicesFile], () => { +gulp.task(cancellationTokenJs, /*help*/ false, [servicesFile], () => { const cancellationTokenProject = tsc.createProject("src/server/cancellationToken/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true)); return cancellationTokenProject.src() .pipe(newer(cancellationTokenJs)) @@ -441,7 +441,7 @@ gulp.task(cancellationTokenJs, false, [servicesFile], () => { // typingsInstallerFile.js const typingsInstallerJs = path.join(builtLocalDirectory, "typingsInstaller.js"); -gulp.task(typingsInstallerJs, false, [servicesFile], () => { +gulp.task(typingsInstallerJs, /*help*/ false, [servicesFile], () => { const cancellationTokenProject = tsc.createProject("src/server/typingsInstaller/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true)); return cancellationTokenProject.src() .pipe(newer(typingsInstallerJs)) @@ -454,7 +454,7 @@ gulp.task(typingsInstallerJs, false, [servicesFile], () => { const serverFile = path.join(builtLocalDirectory, "tsserver.js"); -gulp.task(serverFile, false, [servicesFile, typingsInstallerJs, cancellationTokenJs], () => { +gulp.task(serverFile, /*help*/ false, [servicesFile, typingsInstallerJs, cancellationTokenJs], () => { const serverProject = tsc.createProject("src/server/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true)); return serverProject.src() .pipe(newer(serverFile)) @@ -468,7 +468,7 @@ gulp.task(serverFile, false, [servicesFile, typingsInstallerJs, cancellationToke const tsserverLibraryFile = path.join(builtLocalDirectory, "tsserverlibrary.js"); const tsserverLibraryDefinitionFile = path.join(builtLocalDirectory, "tsserverlibrary.d.ts"); -gulp.task(tsserverLibraryFile, false, [servicesFile], (done) => { +gulp.task(tsserverLibraryFile, /*help*/ false, [servicesFile], (done) => { const serverLibraryProject = tsc.createProject("src/server/tsconfig.library.json", getCompilerSettings({}, /*useBuiltCompiler*/ true)); const {js, dts}: { js: NodeJS.ReadableStream, dts: NodeJS.ReadableStream } = serverLibraryProject.src() .pipe(sourcemaps.init()) @@ -497,7 +497,7 @@ const word2mdTs = path.join(scriptsDirectory, "word2md.ts"); const specWord = path.join(docDirectory, "TypeScript Language Specification.docx"); const specMd = path.join(docDirectory, "spec.md"); -gulp.task(word2mdJs, false, [], () => { +gulp.task(word2mdJs, /*help*/ false, [], () => { const settings: tsc.Settings = getCompilerSettings({ outFile: word2mdJs }, /*useBuiltCompiler*/ false); @@ -509,7 +509,7 @@ gulp.task(word2mdJs, false, [], () => { .pipe(gulp.dest(".")); }); -gulp.task(specMd, false, [word2mdJs], (done) => { +gulp.task(specMd, /*help*/ false, [word2mdJs], (done) => { const specWordFullPath = path.resolve(specWord); const specMDFullPath = path.resolve(specMd); const cmd = "cscript //nologo " + word2mdJs + " \"" + specWordFullPath + "\" " + "\"" + specMDFullPath + "\""; @@ -525,10 +525,10 @@ gulp.task("clean", "Cleans the compiler output, declare files, and tests", [], ( return del([builtDirectory]); }); -gulp.task("useDebugMode", false, [], (done) => { useDebugMode = true; done(); }); -gulp.task("dontUseDebugMode", false, [], (done) => { useDebugMode = false; done(); }); +gulp.task("useDebugMode", /*help*/ false, [], (done) => { useDebugMode = true; done(); }); +gulp.task("dontUseDebugMode", /*help*/ false, [], (done) => { useDebugMode = false; done(); }); -gulp.task("VerifyLKG", false, [], () => { +gulp.task("VerifyLKG", /*help*/ false, [], () => { const expectedFiles = [builtLocalCompiler, servicesFile, serverFile, nodePackageFile, nodeDefinitionsFile, standaloneDefinitionsFile, tsserverLibraryFile, tsserverLibraryDefinitionFile, typingsInstallerJs, cancellationTokenJs].concat(libraryTargets); const missingFiles = expectedFiles.filter(function(f) { return !fs.existsSync(f); @@ -541,7 +541,7 @@ gulp.task("VerifyLKG", false, [], () => { return gulp.src(expectedFiles).pipe(gulp.dest(LKGDirectory)); }); -gulp.task("LKGInternal", false, ["lib", "local"]); +gulp.task("LKGInternal", /*help*/ false, ["lib", "local"]); gulp.task("LKG", "Makes a new LKG out of the built js files", ["clean", "dontUseDebugMode"], () => { return runSequence("LKGInternal", "VerifyLKG"); @@ -550,7 +550,7 @@ gulp.task("LKG", "Makes a new LKG out of the built js files", ["clean", "dontUse // Task to build the tests infrastructure using the built compiler const run = path.join(builtLocalDirectory, "run.js"); -gulp.task(run, false, [servicesFile], () => { +gulp.task(run, /*help*/ false, [servicesFile], () => { const testProject = tsc.createProject("src/harness/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true)); return testProject.src() .pipe(newer(run)) @@ -724,7 +724,7 @@ gulp.task("runtests", const nodeServerOutFile = "tests/webTestServer.js"; const nodeServerInFile = "tests/webTestServer.ts"; -gulp.task(nodeServerOutFile, false, [servicesFile], () => { +gulp.task(nodeServerOutFile, /*help*/ false, [servicesFile], () => { const settings: tsc.Settings = getCompilerSettings({ module: "commonjs" }, /*useBuiltCompiler*/ true); return gulp.src(nodeServerInFile) .pipe(newer(nodeServerOutFile)) @@ -889,7 +889,7 @@ gulp.task("baseline-accept-test262", "Makes the most recent test262 test results // Webhost const webhostPath = "tests/webhost/webtsc.ts"; const webhostJsPath = "tests/webhost/webtsc.js"; -gulp.task(webhostJsPath, false, [servicesFile], () => { +gulp.task(webhostJsPath, /*help*/ false, [servicesFile], () => { const settings: tsc.Settings = getCompilerSettings({ outFile: webhostJsPath }, /*useBuiltCompiler*/ true); @@ -909,7 +909,7 @@ gulp.task("webhost", "Builds the tsc web host", [webhostJsPath], () => { // Perf compiler const perftscPath = "tests/perftsc.ts"; const perftscJsPath = "built/local/perftsc.js"; -gulp.task(perftscJsPath, false, [servicesFile], () => { +gulp.task(perftscJsPath, /*help*/ false, [servicesFile], () => { const settings: tsc.Settings = getCompilerSettings({ outFile: perftscJsPath }, /*useBuiltCompiler*/ true); @@ -927,10 +927,10 @@ gulp.task("perftsc", "Builds augmented version of the compiler for perf tests", // Instrumented compiler const loggedIOpath = path.join(harnessDirectory, "loggedIO.ts"); const loggedIOJsPath = path.join(builtLocalDirectory, "loggedIO.js"); -gulp.task(loggedIOJsPath, false, [], (done) => { +gulp.task(loggedIOJsPath, /*help*/ false, [], (done) => { const temp = path.join(builtLocalDirectory, "temp"); mkdirP(temp, (err) => { - if (err) { console.error(err); done(err); process.exit(1); }; + if (err) { console.error(err); done(err); process.exit(1); } exec(host, [LKGCompiler, "--types --outdir", temp, loggedIOpath], () => { fs.renameSync(path.join(temp, "/harness/loggedIO.js"), loggedIOJsPath); del(temp).then(() => done(), done); @@ -940,7 +940,7 @@ gulp.task(loggedIOJsPath, false, [], (done) => { const instrumenterPath = path.join(harnessDirectory, "instrumenter.ts"); const instrumenterJsPath = path.join(builtLocalDirectory, "instrumenter.js"); -gulp.task(instrumenterJsPath, false, [servicesFile], () => { +gulp.task(instrumenterJsPath, /*help*/ false, [servicesFile], () => { const settings: tsc.Settings = getCompilerSettings({ outFile: instrumenterJsPath }, /*useBuiltCompiler*/ true); diff --git a/Jakefile.js b/Jakefile.js index fa4869c1921bb..79ba3c3f5877d 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -115,6 +115,7 @@ var harnessSources = harnessCoreSources.concat([ "reuseProgramStructure.ts", "textStorage.ts", "cachingInServerLSHost.ts", + "checkerPublicRelationships.ts", "moduleResolution.ts", "tsconfigParsing.ts", "commandLineParsing.ts", @@ -946,7 +947,7 @@ task("generate-code-coverage", ["tests", builtLocalDirectory], function () { // Browser tests var nodeServerOutFile = "tests/webTestServer.js"; var nodeServerInFile = "tests/webTestServer.ts"; -compileFile(nodeServerOutFile, [nodeServerInFile], [builtLocalDirectory, tscFile], [], /*useBuiltCompiler:*/ true, { noOutFile: true }); +compileFile(nodeServerOutFile, [nodeServerInFile], [builtLocalDirectory, tscFile], [], /*useBuiltCompiler:*/ true, { noOutFile: true, lib: "es6" }); desc("Runs browserify on run.js to produce a file suitable for running tests in the browser"); task("browserify", ["tests", builtLocalDirectory, nodeServerOutFile], function() { diff --git a/scripts/tslint/booleanTriviaRule.ts b/scripts/tslint/booleanTriviaRule.ts index e79275c639205..25d001ed9cdc1 100644 --- a/scripts/tslint/booleanTriviaRule.ts +++ b/scripts/tslint/booleanTriviaRule.ts @@ -2,20 +2,12 @@ import * as Lint from "tslint/lib"; import * as ts from "typescript"; export class Rule extends Lint.Rules.AbstractRule { - public static FAILURE_STRING_FACTORY(name: string, currently?: string): string { - const current = currently ? ` (currently '${currently}')` : ""; - return `Tag boolean argument as '${name}'${current}`; - } - public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] { - // Cheat to get type checker - const program = ts.createProgram([sourceFile.fileName], Lint.createCompilerOptions()); - const checker = program.getTypeChecker(); - return this.applyWithFunction(program.getSourceFile(sourceFile.fileName), ctx => walk(ctx, checker)); + return this.applyWithFunction(sourceFile, ctx => walk(ctx)); } } -function walk(ctx: Lint.WalkContext, checker: ts.TypeChecker): void { +function walk(ctx: Lint.WalkContext): void { ts.forEachChild(ctx.sourceFile, recur); function recur(node: ts.Node): void { if (node.kind === ts.SyntaxKind.CallExpression) { @@ -25,39 +17,34 @@ function walk(ctx: Lint.WalkContext, checker: ts.TypeChecker): void { } function checkCall(node: ts.CallExpression): void { - if (!node.arguments || !node.arguments.some(arg => arg.kind === ts.SyntaxKind.TrueKeyword || arg.kind === ts.SyntaxKind.FalseKeyword)) { - return; - } - - const targetCallSignature = checker.getResolvedSignature(node); - if (!targetCallSignature) { - return; - } - - const targetParameters = targetCallSignature.getParameters(); - for (let index = 0; index < targetParameters.length; index++) { - const param = targetParameters[index]; - const arg = node.arguments[index]; - if (!(arg && param)) { + for (const arg of node.arguments) { + if (arg.kind !== ts.SyntaxKind.TrueKeyword && arg.kind !== ts.SyntaxKind.FalseKeyword) { continue; } - const argType = checker.getContextualType(arg); - if (argType && (argType.getFlags() & ts.TypeFlags.Boolean)) { - if (arg.kind !== ts.SyntaxKind.TrueKeyword && arg.kind !== ts.SyntaxKind.FalseKeyword) { + if (node.expression.kind === ts.SyntaxKind.PropertyAccessExpression) { + const methodName = (node.expression as ts.PropertyAccessExpression).name.text + // Skip certain method names whose parameter names are not informative + if (methodName === 'set' || + methodName === 'equal' || + methodName === 'fail' || + methodName === 'isTrue' || + methodName === 'assert') { continue; } - let triviaContent: string | undefined; - const ranges = ts.getLeadingCommentRanges(arg.getFullText(), 0); - if (ranges && ranges.length === 1 && ranges[0].kind === ts.SyntaxKind.MultiLineCommentTrivia) { - triviaContent = arg.getFullText().slice(ranges[0].pos + 2, ranges[0].end - 2); // +/-2 to remove /**/ + } + else if (node.expression.kind === ts.SyntaxKind.Identifier) { + const functionName = (node.expression as ts.Identifier).text; + // Skip certain function names whose parameter names are not informative + if (functionName === 'assert') { + continue; } + } - const paramName = param.getName(); - if (triviaContent !== paramName && triviaContent !== paramName + ":") { - ctx.addFailureAtNode(arg, Rule.FAILURE_STRING_FACTORY(param.getName(), triviaContent)); - } + const ranges = ts.getLeadingCommentRanges(arg.getFullText(), 0); + if (!(ranges && ranges.length === 1 && ranges[0].kind === ts.SyntaxKind.MultiLineCommentTrivia)) { + ctx.addFailureAtNode(arg, 'Tag boolean argument with parameter name'); } } } -} \ No newline at end of file +} diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 650797c6dba2a..4ec65bfce1c95 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -259,7 +259,7 @@ namespace ts { case SyntaxKind.ExportAssignment: return (node).isExportEquals ? "export=" : "default"; case SyntaxKind.BinaryExpression: - switch (getSpecialPropertyAssignmentKind(node)) { + switch (getSpecialPropertyAssignmentKind(node as BinaryExpression)) { case SpecialPropertyAssignmentKind.ModuleExports: // module.exports = ... return "export="; @@ -703,6 +703,7 @@ namespace ts { function isNarrowableReference(expr: Expression): boolean { return expr.kind === SyntaxKind.Identifier || expr.kind === SyntaxKind.ThisKeyword || + expr.kind === SyntaxKind.SuperKeyword || expr.kind === SyntaxKind.PropertyAccessExpression && isNarrowableReference((expr).expression); } @@ -1854,7 +1855,7 @@ namespace ts { } function checkStrictModeNumericLiteral(node: NumericLiteral) { - if (inStrictMode && node.isOctalLiteral) { + if (inStrictMode && node.numericLiteralFlags & NumericLiteralFlags.Octal) { file.bindDiagnostics.push(createDiagnosticForNode(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode)); } } @@ -1910,7 +1911,9 @@ namespace ts { // Here the current node is "foo", which is a container, but the scope of "MyType" should // not be inside "foo". Therefore we always bind @typedef before bind the parent node, // and skip binding this tag later when binding all the other jsdoc tags. - bindJSDocTypedefTagIfAny(node); + if (isInJavaScriptFile(node)) { + bindJSDocTypedefTagIfAny(node); + } // First we bind declaration nodes to a symbol if possible. We'll both create a symbol // and then potentially add the symbol to an appropriate symbol table. Possible @@ -2017,30 +2020,28 @@ namespace ts { } break; case SyntaxKind.BinaryExpression: - if (isInJavaScriptFile(node)) { - const specialKind = getSpecialPropertyAssignmentKind(node); - switch (specialKind) { - case SpecialPropertyAssignmentKind.ExportsProperty: - bindExportsPropertyAssignment(node); - break; - case SpecialPropertyAssignmentKind.ModuleExports: - bindModuleExportsAssignment(node); - break; - case SpecialPropertyAssignmentKind.PrototypeProperty: - bindPrototypePropertyAssignment(node); - break; - case SpecialPropertyAssignmentKind.ThisProperty: - bindThisPropertyAssignment(node); - break; - case SpecialPropertyAssignmentKind.Property: - bindStaticPropertyAssignment(node); - break; - case SpecialPropertyAssignmentKind.None: - // Nothing to do - break; - default: - Debug.fail("Unknown special property assignment kind"); - } + const specialKind = getSpecialPropertyAssignmentKind(node as BinaryExpression); + switch (specialKind) { + case SpecialPropertyAssignmentKind.ExportsProperty: + bindExportsPropertyAssignment(node); + break; + case SpecialPropertyAssignmentKind.ModuleExports: + bindModuleExportsAssignment(node); + break; + case SpecialPropertyAssignmentKind.PrototypeProperty: + bindPrototypePropertyAssignment(node); + break; + case SpecialPropertyAssignmentKind.ThisProperty: + bindThisPropertyAssignment(node); + break; + case SpecialPropertyAssignmentKind.Property: + bindStaticPropertyAssignment(node); + break; + case SpecialPropertyAssignmentKind.None: + // Nothing to do + break; + default: + Debug.fail("Unknown special property assignment kind"); } return checkStrictModeBinaryExpression(node); case SyntaxKind.CatchClause: @@ -3329,6 +3330,18 @@ namespace ts { transformFlags |= TransformFlags.AssertES2015; break; + case SyntaxKind.StringLiteral: + if ((node).hasExtendedUnicodeEscape) { + transformFlags |= TransformFlags.AssertES2015; + } + break; + + case SyntaxKind.NumericLiteral: + if ((node).numericLiteralFlags & NumericLiteralFlags.BinaryOrOctalSpecifier) { + transformFlags |= TransformFlags.AssertES2015; + } + break; + case SyntaxKind.ForOfStatement: // This node is either ES2015 syntax or ES2017 syntax (if it is a for-await-of). if ((node).awaitModifier) { diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 70cbda14f6db4..4829313d10670 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -47,6 +47,7 @@ namespace ts { let typeCount = 0; let symbolCount = 0; + let symbolInstantiationDepth = 0; const emptyArray: any[] = []; const emptySymbols = createMap(); @@ -61,6 +62,7 @@ namespace ts { const noImplicitThis = compilerOptions.noImplicitThis === undefined ? compilerOptions.strict : compilerOptions.noImplicitThis; const emitResolver = createResolver(); + const nodeBuilder = createNodeBuilder(); const undefinedSymbol = createSymbol(SymbolFlags.Property, "undefined"); undefinedSymbol.declarations = []; @@ -106,6 +108,9 @@ namespace ts { getParameterType: getTypeAtPosition, getReturnTypeOfSignature, getNonNullableType, + typeToTypeNode: nodeBuilder.typeToTypeNode, + indexInfoToIndexSignatureDeclaration: nodeBuilder.indexInfoToIndexSignatureDeclaration, + signatureToSignatureDeclaration: nodeBuilder.signatureToSignatureDeclaration, getSymbolsInScope: (location, meaning) => { location = getParseTreeNode(location); return location ? getSymbolsInScope(location, meaning) : []; @@ -187,7 +192,58 @@ namespace ts { // since we are only interested in declarations of the module itself return tryFindAmbientModule(moduleName, /*withAugmentations*/ false); }, - getApparentType + getApparentType, + isIdenticalTo: (a, b) => checkTypeRelatedTo(a, b, identityRelation, /*errorNode*/undefined), + isSubtypeOf: (a, b) => checkTypeRelatedTo(a, b, subtypeRelation, /*errorNode*/undefined), + isAssignableTo: (a, b) => checkTypeRelatedTo(a, b, assignableRelation, /*errorNode*/undefined), + isComparableTo: areTypesComparable, + isInstantiationOf: (a, b) => { + return a && b && (a.target === b); + }, + + lookupGlobalType: name => { + const symbol = getSymbol(globals, name, SymbolFlags.Type); + return symbol ? getDeclaredTypeOfSymbol(symbol) : unknownType; + }, + lookupGlobalValueType: name => { + const symbol = getSymbol(globals, name, SymbolFlags.Value); + return symbol ? getTypeOfSymbol(symbol) : unknownType; + }, + lookupTypeAt: (name, node) => { + const symbol = resolveName(node, name, SymbolFlags.Type, /*nameNotFoundMessage*/undefined, /*nameArg*/undefined); + return symbol ? getDeclaredTypeOfSymbol(symbol) : unknownType; + }, + lookupValueTypeAt: (name, node) => { + const symbol = resolveName(node, name, SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/undefined); + return symbol ? getTypeOfSymbol(symbol) : unknownType; + }, + getTypeOfSymbol, + + getAnyType: () => anyType, + getStringType: () => stringType, + getNumberType: () => numberType, + getBooleanType: () => booleanType, + getVoidType: () => voidType, + getUndefinedType: () => undefinedType, + getNullType: () => nullType, + getESSymbolType: () => esSymbolType, + getNeverType: () => neverType, + getUnknownType: () => unknownType, + getStringLiteralType: (text: string) => { + /* tslint:disable:no-null-keyword */ + Debug.assert(text !== undefined && text !== null); + /* tslint:enable:no-null-keyword */ + return getLiteralTypeForText(TypeFlags.StringLiteral, "" + text); + }, + getNumberLiteralType: (text: string) => { + /* tslint:disable:no-null-keyword */ + Debug.assert(text !== undefined && text !== null); + /* tslint:enable:no-null-keyword */ + Debug.assert(typeof text === "string" || typeof text === "number"); // While not formally part of the function signature, allow coercions from numbers + return getLiteralTypeForText(TypeFlags.NumberLiteral, "" + text); + }, + getFalseType: () => falseType, + getTrueType: () => trueType, }; const tupleTypes: GenericType[] = []; @@ -199,8 +255,6 @@ namespace ts { const evolvingArrayTypes: EvolvingArrayType[] = []; const unknownSymbol = createSymbol(SymbolFlags.Property, "unknown"); - const untypedModuleSymbol = createSymbol(SymbolFlags.ValueModule, ""); - untypedModuleSymbol.exports = createMap(); const resolvingSymbol = createSymbol(0, "__resolving__"); const anyType = createIntrinsicType(TypeFlags.Any, "any"); @@ -251,7 +305,7 @@ namespace ts { * List of every ambient module with a "*" wildcard. * Unlike other ambient modules, these can't be stored in `globals` because symbol tables only deal with exact matches. * This is only used if there is no exact match. - */ + */ let patternAmbientModules: PatternAmbientModule[]; let globalObjectType: ObjectType; @@ -489,6 +543,10 @@ namespace ts { return symbol; } + function isTransientSymbol(symbol: Symbol): symbol is TransientSymbol { + return (symbol.flags & SymbolFlags.Transient) !== 0; + } + function getExcludedSymbolFlags(flags: SymbolFlags): SymbolFlags { let result: SymbolFlags = 0; if (flags & SymbolFlags.BlockScopedVariable) result |= SymbolFlags.BlockScopedVariableExcludes; @@ -713,7 +771,7 @@ namespace ts { } // declaration is after usage // can be legal if usage is deferred (i.e. inside function or in initializer of instance property) - if (isUsedInFunctionOrInstanceProperty(usage)) { + if (isUsedInFunctionOrInstanceProperty(usage, declaration)) { return true; } const sourceFiles = host.getSourceFiles(); @@ -743,9 +801,9 @@ namespace ts { // declaration is after usage, but it can still be legal if usage is deferred: // 1. inside a function // 2. inside an instance property initializer, a reference to a non-instance property + // 3. inside a static property initializer, a reference to a static method in the same class const container = getEnclosingBlockScopeContainer(declaration); - const isInstanceProperty = declaration.kind === SyntaxKind.PropertyDeclaration && !(getModifierFlags(declaration) & ModifierFlags.Static); - return isUsedInFunctionOrInstanceProperty(usage, isInstanceProperty, container); + return isUsedInFunctionOrInstanceProperty(usage, declaration, container); function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration: VariableDeclaration, usage: Node): boolean { const container = getEnclosingBlockScopeContainer(declaration); @@ -774,7 +832,7 @@ namespace ts { return false; } - function isUsedInFunctionOrInstanceProperty(usage: Node, isDeclarationInstanceProperty?: boolean, container?: Node): boolean { + function isUsedInFunctionOrInstanceProperty(usage: Node, declaration: Node, container?: Node): boolean { let current = usage; while (current) { if (current === container) { @@ -785,13 +843,22 @@ namespace ts { return true; } - const initializerOfInstanceProperty = current.parent && + const initializerOfProperty = current.parent && current.parent.kind === SyntaxKind.PropertyDeclaration && - (getModifierFlags(current.parent) & ModifierFlags.Static) === 0 && (current.parent).initializer === current; - if (initializerOfInstanceProperty) { - return !isDeclarationInstanceProperty; + if (initializerOfProperty) { + if (getModifierFlags(current.parent) & ModifierFlags.Static) { + if (declaration.kind === SyntaxKind.MethodDeclaration) { + return true; + } + } + else { + const isDeclarationInstanceProperty = declaration.kind === SyntaxKind.PropertyDeclaration && !(getModifierFlags(declaration) & ModifierFlags.Static); + if (!isDeclarationInstanceProperty || getContainingClass(usage) !== getContainingClass(declaration)) { + return true; + } + } } current = current.parent; @@ -1249,7 +1316,7 @@ namespace ts { if (moduleSymbol) { let exportDefaultSymbol: Symbol; - if (isUntypedOrShorthandAmbientModuleSymbol(moduleSymbol)) { + if (isShorthandAmbientModuleSymbol(moduleSymbol)) { exportDefaultSymbol = moduleSymbol; } else { @@ -1329,7 +1396,7 @@ namespace ts { if (targetSymbol) { const name = specifier.propertyName || specifier.name; if (name.text) { - if (isUntypedOrShorthandAmbientModuleSymbol(moduleSymbol)) { + if (isShorthandAmbientModuleSymbol(moduleSymbol)) { return moduleSymbol; } @@ -1503,9 +1570,23 @@ namespace ts { } } else if (name.kind === SyntaxKind.QualifiedName || name.kind === SyntaxKind.PropertyAccessExpression) { - const left = name.kind === SyntaxKind.QualifiedName ? (name).left : (name).expression; - const right = name.kind === SyntaxKind.QualifiedName ? (name).right : (name).name; + let left: EntityNameOrEntityNameExpression; + if (name.kind === SyntaxKind.QualifiedName) { + left = (name).left; + } + else if (name.kind === SyntaxKind.PropertyAccessExpression && + (name.expression.kind === SyntaxKind.ParenthesizedExpression || isEntityNameExpression(name.expression))) { + left = name.expression; + } + else { + // If the expression in property-access expression is not entity-name or parenthsizedExpression (e.g. it is a call expression), it won't be able to successfully resolve the name. + // This is the case when we are trying to do any language service operation in heritage clauses. By return undefined, the getSymbolOfEntityNameOrPropertyAccessExpression + // will attempt to checkPropertyAccessExpression to resolve symbol. + // i.e class C extends foo()./*do language service operation here*/B {} + return undefined; + } + const right = name.kind === SyntaxKind.QualifiedName ? name.right : name.name; const namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors, /*dontResolveAlias*/ false, location); if (!namespace || nodeIsMissing(right)) { return undefined; @@ -1521,6 +1602,15 @@ namespace ts { return undefined; } } + else if (name.kind === SyntaxKind.ParenthesizedExpression) { + // If the expression in parenthesizedExpression is not an entity-name (e.g. it is a call expression), it won't be able to successfully resolve the name. + // This is the case when we are trying to do any language service operation in heritage clauses. + // By return undefined, the getSymbolOfEntityNameOrPropertyAccessExpression will attempt to checkPropertyAccessExpression to resolve symbol. + // i.e class C extends foo()./*do language service operation here*/B {} + return isEntityNameExpression(name.expression) ? + resolveEntityName(name.expression as EntityNameOrEntityNameExpression, meaning, ignoreErrors, dontResolveAlias, location) : + undefined; + } else { Debug.fail("Unknown entity name kind."); } @@ -1533,7 +1623,7 @@ namespace ts { } function resolveExternalModuleNameWorker(location: Node, moduleReferenceExpression: Expression, moduleNotFoundError: DiagnosticMessage, isForAugmentation = false): Symbol { - if (moduleReferenceExpression.kind !== SyntaxKind.StringLiteral) { + if (moduleReferenceExpression.kind !== SyntaxKind.StringLiteral && moduleReferenceExpression.kind !== SyntaxKind.NoSubstitutionTemplateLiteral) { return; } @@ -1582,19 +1672,15 @@ namespace ts { if (isForAugmentation) { const diag = Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented; error(errorNode, diag, moduleReference, resolvedModule.resolvedFileName); - return undefined; } else if (noImplicitAny && moduleNotFoundError) { error(errorNode, Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type, moduleReference, resolvedModule.resolvedFileName); - return undefined; } - // Unlike a failed import, an untyped module produces a dummy symbol. - // This is checked for by `isUntypedOrShorthandAmbientModuleSymbol`. - // This must be different than `unknownSymbol` because `getBaseConstructorTypeOfClass` won't fail for `unknownSymbol`. - return untypedModuleSymbol; + // Failed imports and untyped modules are both treated in an untyped manner; only difference is whether we give a diagnostic first. + return undefined; } if (moduleNotFoundError) { @@ -2198,6 +2284,584 @@ namespace ts { return result; } + function createNodeBuilder() { + let context: NodeBuilderContext; + + return { + typeToTypeNode: (type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags) => { + context = createNodeBuilderContext(enclosingDeclaration, flags); + const resultingNode = typeToTypeNodeHelper(type); + const result = context.encounteredError ? undefined : resultingNode; + return result; + }, + indexInfoToIndexSignatureDeclaration: (indexInfo: IndexInfo, kind: IndexKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags) => { + context = createNodeBuilderContext(enclosingDeclaration, flags); + const resultingNode = indexInfoToIndexSignatureDeclarationHelper(indexInfo, kind); + const result = context.encounteredError ? undefined : resultingNode; + return result; + }, + signatureToSignatureDeclaration: (signature: Signature, kind: SyntaxKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags) => { + context = createNodeBuilderContext(enclosingDeclaration, flags); + const resultingNode = signatureToSignatureDeclarationHelper(signature, kind); + const result = context.encounteredError ? undefined : resultingNode; + return result; + } + }; + + interface NodeBuilderContext { + readonly enclosingDeclaration: Node | undefined; + readonly flags: NodeBuilderFlags | undefined; + encounteredError: boolean; + inObjectTypeLiteral: boolean; + checkAlias: boolean; + symbolStack: Symbol[] | undefined; + } + + function createNodeBuilderContext(enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): NodeBuilderContext { + return { + enclosingDeclaration, + flags, + encounteredError: false, + inObjectTypeLiteral: false, + checkAlias: true, + symbolStack: undefined + }; + } + + function typeToTypeNodeHelper(type: Type): TypeNode { + if (!type) { + context.encounteredError = true; + // TODO(aozgaa): should we return implict any (undefined) or explicit any (keywordtypenode)? + return undefined; + } + + if (type.flags & TypeFlags.Any) { + return createKeywordTypeNode(SyntaxKind.AnyKeyword); + } + if (type.flags & TypeFlags.String) { + return createKeywordTypeNode(SyntaxKind.StringKeyword); + } + if (type.flags & TypeFlags.Number) { + return createKeywordTypeNode(SyntaxKind.NumberKeyword); + } + if (type.flags & TypeFlags.Boolean) { + return createKeywordTypeNode(SyntaxKind.BooleanKeyword); + } + if (type.flags & TypeFlags.Enum) { + const name = symbolToName(type.symbol, /*expectsIdentifier*/ false); + return createTypeReferenceNode(name, /*typeArguments*/ undefined); + } + if (type.flags & (TypeFlags.StringLiteral)) { + return createLiteralTypeNode((createLiteral((type).text))); + } + if (type.flags & (TypeFlags.NumberLiteral)) { + return createLiteralTypeNode((createNumericLiteral((type).text))); + } + if (type.flags & TypeFlags.BooleanLiteral) { + return (type).intrinsicName === "true" ? createTrue() : createFalse(); + } + if (type.flags & TypeFlags.EnumLiteral) { + const name = symbolToName(type.symbol, /*expectsIdentifier*/ false); + return createTypeReferenceNode(name, /*typeArguments*/ undefined); + } + if (type.flags & TypeFlags.Void) { + return createKeywordTypeNode(SyntaxKind.VoidKeyword); + } + if (type.flags & TypeFlags.Undefined) { + return createKeywordTypeNode(SyntaxKind.UndefinedKeyword); + } + if (type.flags & TypeFlags.Null) { + return createKeywordTypeNode(SyntaxKind.NullKeyword); + } + if (type.flags & TypeFlags.Never) { + return createKeywordTypeNode(SyntaxKind.NeverKeyword); + } + if (type.flags & TypeFlags.ESSymbol) { + return createKeywordTypeNode(SyntaxKind.SymbolKeyword); + } + if (type.flags & TypeFlags.NonPrimitive) { + return createKeywordTypeNode(SyntaxKind.ObjectKeyword); + } + if (type.flags & TypeFlags.TypeParameter && (type as TypeParameter).isThisType) { + if (context.inObjectTypeLiteral) { + if (!context.encounteredError && !(context.flags & NodeBuilderFlags.allowThisInObjectLiteral)) { + context.encounteredError = true; + } + } + return createThis(); + } + + const objectFlags = getObjectFlags(type); + + if (objectFlags & ObjectFlags.Reference) { + Debug.assert(!!(type.flags & TypeFlags.Object)); + return typeReferenceToTypeNode(type); + } + if (objectFlags & ObjectFlags.ClassOrInterface) { + Debug.assert(!!(type.flags & TypeFlags.Object)); + const name = symbolToName(type.symbol, /*expectsIdentifier*/ false); + // TODO(aozgaa): handle type arguments. + return createTypeReferenceNode(name, /*typeArguments*/ undefined); + } + if (type.flags & TypeFlags.TypeParameter) { + const name = symbolToName(type.symbol, /*expectsIdentifier*/ false); + // Ignore constraint/default when creating a usage (as opposed to declaration) of a type parameter. + return createTypeReferenceNode(name, /*typeArguments*/ undefined); + } + + if (context.checkAlias && type.aliasSymbol) { + const name = symbolToName(type.aliasSymbol, /*expectsIdentifier*/ false); + const typeArgumentNodes = type.aliasTypeArguments && mapToTypeNodeArray(type.aliasTypeArguments); + return createTypeReferenceNode(name, typeArgumentNodes); + } + context.checkAlias = false; + + if (type.flags & TypeFlags.Union) { + const formattedUnionTypes = formatUnionTypes((type).types); + const unionTypeNodes = formattedUnionTypes && mapToTypeNodeArray(formattedUnionTypes); + if (unionTypeNodes && unionTypeNodes.length > 0) { + return createUnionOrIntersectionTypeNode(SyntaxKind.UnionType, unionTypeNodes); + } + else { + if (!context.encounteredError && !(context.flags & NodeBuilderFlags.allowEmptyUnionOrIntersection)) { + context.encounteredError = true; + } + return undefined; + } + } + + if (type.flags & TypeFlags.Intersection) { + return createUnionOrIntersectionTypeNode(SyntaxKind.IntersectionType, mapToTypeNodeArray((type as UnionType).types)); + } + + if (objectFlags & (ObjectFlags.Anonymous | ObjectFlags.Mapped)) { + Debug.assert(!!(type.flags & TypeFlags.Object)); + // The type is an object literal type. + return createAnonymousTypeNode(type); + } + + if (type.flags & TypeFlags.Index) { + const indexedType = (type).type; + const indexTypeNode = typeToTypeNodeHelper(indexedType); + return createTypeOperatorNode(indexTypeNode); + } + if (type.flags & TypeFlags.IndexedAccess) { + const objectTypeNode = typeToTypeNodeHelper((type).objectType); + const indexTypeNode = typeToTypeNodeHelper((type).indexType); + return createIndexedAccessTypeNode(objectTypeNode, indexTypeNode); + } + + Debug.fail("Should be unreachable."); + + function mapToTypeNodeArray(types: Type[]): TypeNode[] { + const result = []; + for (const type of types) { + const typeNode = typeToTypeNodeHelper(type); + if (typeNode) { + result.push(typeNode); + } + } + return result; + } + + function createMappedTypeNodeFromType(type: MappedType) { + Debug.assert(!!(type.flags & TypeFlags.Object)); + const typeParameter = getTypeParameterFromMappedType(type); + const typeParameterNode = typeParameterToDeclaration(typeParameter); + + const templateType = getTemplateTypeFromMappedType(type); + const templateTypeNode = typeToTypeNodeHelper(templateType); + const readonlyToken = type.declaration && type.declaration.readonlyToken ? createToken(SyntaxKind.ReadonlyKeyword) : undefined; + const questionToken = type.declaration && type.declaration.questionToken ? createToken(SyntaxKind.QuestionToken) : undefined; + + return createMappedTypeNode(readonlyToken, typeParameterNode, questionToken, templateTypeNode); + } + + function createAnonymousTypeNode(type: ObjectType): TypeNode { + const symbol = type.symbol; + if (symbol) { + // Always use 'typeof T' for type of class, enum, and module objects + if (symbol.flags & SymbolFlags.Class && !getBaseTypeVariableOfClass(symbol) || + symbol.flags & (SymbolFlags.Enum | SymbolFlags.ValueModule) || + shouldWriteTypeOfFunctionSymbol()) { + return createTypeQueryNodeFromSymbol(symbol); + } + else if (contains(context.symbolStack, symbol)) { + // If type is an anonymous type literal in a type alias declaration, use type alias name + const typeAlias = getTypeAliasForTypeLiteral(type); + if (typeAlias) { + // The specified symbol flags need to be reinterpreted as type flags + const entityName = symbolToName(typeAlias, /*expectsIdentifier*/ false); + return createTypeReferenceNode(entityName, /*typeArguments*/ undefined); + } + else { + return createKeywordTypeNode(SyntaxKind.AnyKeyword); + } + } + else { + // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead + // of types allows us to catch circular references to instantiations of the same anonymous type + if (!context.symbolStack) { + context.symbolStack = []; + } + context.symbolStack.push(symbol); + const result = createTypeNodeFromObjectType(type); + context.symbolStack.pop(); + return result; + } + } + else { + // Anonymous types without a symbol are never circular. + return createTypeNodeFromObjectType(type); + } + + function shouldWriteTypeOfFunctionSymbol() { + const isStaticMethodSymbol = !!(symbol.flags & SymbolFlags.Method && // typeof static method + forEach(symbol.declarations, declaration => getModifierFlags(declaration) & ModifierFlags.Static)); + const isNonLocalFunctionSymbol = !!(symbol.flags & SymbolFlags.Function) && + (symbol.parent || // is exported function symbol + forEach(symbol.declarations, declaration => + declaration.parent.kind === SyntaxKind.SourceFile || declaration.parent.kind === SyntaxKind.ModuleBlock)); + if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { + // typeof is allowed only for static/non local functions + return contains(context.symbolStack, symbol); // it is type of the symbol uses itself recursively + } + } + } + + function createTypeNodeFromObjectType(type: ObjectType): TypeNode { + if (type.objectFlags & ObjectFlags.Mapped) { + if (getConstraintTypeFromMappedType(type).flags & (TypeFlags.TypeParameter | TypeFlags.Index)) { + return createMappedTypeNodeFromType(type); + } + } + + const resolved = resolveStructuredTypeMembers(type); + if (!resolved.properties.length && !resolved.stringIndexInfo && !resolved.numberIndexInfo) { + if (!resolved.callSignatures.length && !resolved.constructSignatures.length) { + return createTypeLiteralNode(/*members*/ undefined); + } + + if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) { + const signature = resolved.callSignatures[0]; + return signatureToSignatureDeclarationHelper(signature, SyntaxKind.FunctionType); + } + if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) { + const signature = resolved.constructSignatures[0]; + return signatureToSignatureDeclarationHelper(signature, SyntaxKind.ConstructorType); + } + } + + const saveInObjectTypeLiteral = context.inObjectTypeLiteral; + context.inObjectTypeLiteral = true; + const members = createTypeNodesFromResolvedType(resolved); + context.inObjectTypeLiteral = saveInObjectTypeLiteral; + return createTypeLiteralNode(members); + } + + function createTypeQueryNodeFromSymbol(symbol: Symbol) { + const entityName = symbolToName(symbol, /*expectsIdentifier*/ false); + return createTypeQueryNode(entityName); + } + + function typeReferenceToTypeNode(type: TypeReference) { + const typeArguments: Type[] = type.typeArguments || emptyArray; + if (type.target === globalArrayType) { + const elementType = typeToTypeNodeHelper(typeArguments[0]); + return createArrayTypeNode(elementType); + } + else if (type.target.objectFlags & ObjectFlags.Tuple) { + if (typeArguments.length > 0) { + const tupleConstituentNodes = mapToTypeNodeArray(typeArguments.slice(0, getTypeReferenceArity(type))); + if (tupleConstituentNodes && tupleConstituentNodes.length > 0) { + return createTupleTypeNode(tupleConstituentNodes); + } + } + if (!context.encounteredError && !(context.flags & NodeBuilderFlags.allowEmptyTuple)) { + context.encounteredError = true; + } + return undefined; + } + else { + const outerTypeParameters = type.target.outerTypeParameters; + let i = 0; + let qualifiedName: QualifiedName | undefined = undefined; + if (outerTypeParameters) { + const length = outerTypeParameters.length; + while (i < length) { + // Find group of type arguments for type parameters with the same declaring container. + const start = i; + const parent = getParentSymbolOfTypeParameter(outerTypeParameters[i]); + do { + i++; + } while (i < length && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent); + // When type parameters are their own type arguments for the whole group (i.e. we have + // the default outer type arguments), we don't show the group. + if (!rangeEquals(outerTypeParameters, typeArguments, start, i)) { + const qualifiedNamePart = symbolToName(parent, /*expectsIdentifier*/ true); + if (!qualifiedName) { + qualifiedName = createQualifiedName(qualifiedNamePart, /*right*/ undefined); + } + else { + Debug.assert(!qualifiedName.right); + qualifiedName.right = qualifiedNamePart; + qualifiedName = createQualifiedName(qualifiedName, /*right*/ undefined); + } + } + } + } + let entityName: EntityName = undefined; + const nameIdentifier = symbolToName(type.symbol, /*expectsIdentifier*/ true); + if (qualifiedName) { + Debug.assert(!qualifiedName.right); + qualifiedName.right = nameIdentifier; + entityName = qualifiedName; + } + else { + entityName = nameIdentifier; + } + const typeParameterCount = (type.target.typeParameters || emptyArray).length; + const typeArgumentNodes = some(typeArguments) ? mapToTypeNodeArray(typeArguments.slice(i, typeParameterCount - i)) : undefined; + return createTypeReferenceNode(entityName, typeArgumentNodes); + } + } + + function createTypeNodesFromResolvedType(resolvedType: ResolvedType): TypeElement[] { + const typeElements: TypeElement[] = []; + for (const signature of resolvedType.callSignatures) { + typeElements.push(signatureToSignatureDeclarationHelper(signature, SyntaxKind.CallSignature)); + } + for (const signature of resolvedType.constructSignatures) { + typeElements.push(signatureToSignatureDeclarationHelper(signature, SyntaxKind.ConstructSignature)); + } + if (resolvedType.stringIndexInfo) { + typeElements.push(indexInfoToIndexSignatureDeclarationHelper(resolvedType.stringIndexInfo, IndexKind.String)); + } + if (resolvedType.numberIndexInfo) { + typeElements.push(indexInfoToIndexSignatureDeclarationHelper(resolvedType.numberIndexInfo, IndexKind.Number)); + } + + const properties = resolvedType.properties; + if (!properties) { + return typeElements; + } + + for (const propertySymbol of properties) { + const propertyType = getTypeOfSymbol(propertySymbol); + const oldDeclaration = propertySymbol.declarations && propertySymbol.declarations[0] as TypeElement; + if (!oldDeclaration) { + return; + } + const propertyName = oldDeclaration.name; + const optionalToken = propertySymbol.flags & SymbolFlags.Optional ? createToken(SyntaxKind.QuestionToken) : undefined; + if (propertySymbol.flags & (SymbolFlags.Function | SymbolFlags.Method) && !getPropertiesOfObjectType(propertyType).length) { + const signatures = getSignaturesOfType(propertyType, SignatureKind.Call); + for (const signature of signatures) { + const methodDeclaration = signatureToSignatureDeclarationHelper(signature, SyntaxKind.MethodSignature); + methodDeclaration.name = propertyName; + methodDeclaration.questionToken = optionalToken; + typeElements.push(methodDeclaration); + } + } + else { + + // TODO(aozgaa): should we create a node with explicit or implict any? + const propertyTypeNode = propertyType ? typeToTypeNodeHelper(propertyType) : createKeywordTypeNode(SyntaxKind.AnyKeyword); + typeElements.push(createPropertySignature( + propertyName, + optionalToken, + propertyTypeNode, + /*initializer*/undefined)); + } + } + return typeElements.length ? typeElements : undefined; + } + } + + function indexInfoToIndexSignatureDeclarationHelper(indexInfo: IndexInfo, kind: IndexKind): IndexSignatureDeclaration { + const indexerTypeNode = createKeywordTypeNode(kind === IndexKind.String ? SyntaxKind.StringKeyword : SyntaxKind.NumberKeyword); + const name = getNameFromIndexInfo(indexInfo); + + const indexingParameter = createParameter( + /*decorators*/ undefined, + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, + name, + /*questionToken*/ undefined, + indexerTypeNode, + /*initializer*/ undefined); + const typeNode = typeToTypeNodeHelper(indexInfo.type); + return createIndexSignatureDeclaration( + /*decorators*/ undefined, + indexInfo.isReadonly ? [createToken(SyntaxKind.ReadonlyKeyword)] : undefined, + [indexingParameter], + typeNode); + } + + function signatureToSignatureDeclarationHelper(signature: Signature, kind: SyntaxKind): SignatureDeclaration { + + const typeParameters = signature.typeParameters && signature.typeParameters.map(parameter => typeParameterToDeclaration(parameter)); + const parameters = signature.parameters.map(parameter => symbolToParameterDeclaration(parameter)); + let returnTypeNode: TypeNode | TypePredicate; + if (signature.typePredicate) { + const typePredicate = signature.typePredicate; + const parameterName = typePredicate.kind === TypePredicateKind.Identifier ? createIdentifier((typePredicate).parameterName) : createThisTypeNode(); + const typeNode = typeToTypeNodeHelper(typePredicate.type); + returnTypeNode = createTypePredicateNode(parameterName, typeNode); + } + else { + const returnType = getReturnTypeOfSignature(signature); + returnTypeNode = returnType && typeToTypeNodeHelper(returnType); + } + const returnTypeNodeExceptAny = returnTypeNode && returnTypeNode.kind !== SyntaxKind.AnyKeyword ? returnTypeNode : undefined; + + return createSignatureDeclaration(kind, typeParameters, parameters, returnTypeNodeExceptAny); + } + + function typeParameterToDeclaration(type: TypeParameter): TypeParameterDeclaration { + const constraint = getConstraintFromTypeParameter(type); + const constraintNode = constraint && typeToTypeNodeHelper(constraint); + const defaultParameter = getDefaultFromTypeParameter(type); + const defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter); + const name = symbolToName(type.symbol, /*expectsIdentifier*/ true); + return createTypeParameterDeclaration(name, constraintNode, defaultParameterNode); + } + + function symbolToParameterDeclaration(parameterSymbol: Symbol): ParameterDeclaration { + const parameterDeclaration = getDeclarationOfKind(parameterSymbol, SyntaxKind.Parameter); + const parameterType = getTypeOfSymbol(parameterSymbol); + const parameterTypeNode = typeToTypeNodeHelper(parameterType); + // TODO(aozgaa): In the future, check initializer accessibility. + const parameterNode = createParameter( + parameterDeclaration.decorators, + parameterDeclaration.modifiers, + parameterDeclaration.dotDotDotToken && createToken(SyntaxKind.DotDotDotToken), + // Clone name to remove trivia. + getSynthesizedClone(parameterDeclaration.name), + parameterDeclaration.questionToken && createToken(SyntaxKind.QuestionToken), + parameterTypeNode, + parameterDeclaration.initializer); + return parameterNode; + } + + function symbolToName(symbol: Symbol, expectsIdentifier: true): Identifier; + function symbolToName(symbol: Symbol, expectsIdentifier: false): EntityName; + function symbolToName(symbol: Symbol, expectsIdentifier: boolean): EntityName { + + // Try to get qualified name if the symbol is not a type parameter and there is an enclosing declaration. + let chain: Symbol[]; + const isTypeParameter = symbol.flags & SymbolFlags.TypeParameter; + if (!isTypeParameter && context.enclosingDeclaration) { + chain = getSymbolChain(symbol, SymbolFlags.None, /*endOfChain*/ true); + Debug.assert(chain && chain.length > 0); + } + else { + chain = [symbol]; + } + + if (expectsIdentifier && chain.length !== 1 + && !context.encounteredError + && !(context.flags & NodeBuilderFlags.allowQualifedNameInPlaceOfIdentifier)) { + context.encounteredError = true; + } + return createEntityNameFromSymbolChain(chain, chain.length - 1); + + function createEntityNameFromSymbolChain(chain: Symbol[], index: number): EntityName { + Debug.assert(chain && 0 <= index && index < chain.length); + // const parentIndex = index - 1; + const symbol = chain[index]; + let typeParameterString = ""; + if (index > 0) { + + const parentSymbol = chain[index - 1]; + let typeParameters: TypeParameter[]; + if (getCheckFlags(symbol) & CheckFlags.Instantiated) { + typeParameters = getTypeParametersOfClassOrInterface(parentSymbol); + } + else { + const targetSymbol = getTargetSymbol(parentSymbol); + if (targetSymbol.flags & (SymbolFlags.Class | SymbolFlags.Interface | SymbolFlags.TypeAlias)) { + typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + } + } + if (typeParameters && typeParameters.length > 0) { + if (!context.encounteredError && !(context.flags & NodeBuilderFlags.allowTypeParameterInQualifiedName)) { + context.encounteredError = true; + } + const writer = getSingleLineStringWriter(); + const displayBuilder = getSymbolDisplayBuilder(); + displayBuilder.buildDisplayForTypeParametersAndDelimiters(typeParameters, writer, context.enclosingDeclaration, 0); + typeParameterString = writer.string(); + releaseStringWriter(writer); + + } + } + const symbolName = getNameOfSymbol(symbol); + const symbolNameWithTypeParameters = typeParameterString.length > 0 ? `${symbolName}<${typeParameterString}>` : symbolName; + const identifier = createIdentifier(symbolNameWithTypeParameters); + + return index > 0 ? createQualifiedName(createEntityNameFromSymbolChain(chain, index - 1), identifier) : identifier; + } + + /** @param endOfChain Set to false for recursive calls; non-recursive calls should always output something. */ + function getSymbolChain(symbol: Symbol, meaning: SymbolFlags, endOfChain: boolean): Symbol[] | undefined { + let accessibleSymbolChain = getAccessibleSymbolChain(symbol, context.enclosingDeclaration, meaning, /*useOnlyExternalAliasing*/false); + let parentSymbol: Symbol; + + if (!accessibleSymbolChain || + needsQualification(accessibleSymbolChain[0], context.enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) { + + // Go up and add our parent. + const parent = getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol); + if (parent) { + const parentChain = getSymbolChain(parent, getQualifiedLeftMeaning(meaning), /*endOfChain*/ false); + if (parentChain) { + parentSymbol = parent; + accessibleSymbolChain = parentChain.concat(accessibleSymbolChain || [symbol]); + } + } + } + + if (accessibleSymbolChain) { + return accessibleSymbolChain; + } + if ( + // If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols. + endOfChain || + // If a parent symbol is an external module, don't write it. (We prefer just `x` vs `"foo/bar".x`.) + !(!parentSymbol && ts.forEach(symbol.declarations, hasExternalModuleSymbol)) && + // If a parent symbol is an anonymous type, don't write it. + !(symbol.flags & (SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral))) { + + return [symbol]; + } + } + + function getNameOfSymbol(symbol: Symbol): string { + const declaration = firstOrUndefined(symbol.declarations); + if (declaration) { + if (declaration.name) { + return declarationNameToString(declaration.name); + } + if (declaration.parent && declaration.parent.kind === SyntaxKind.VariableDeclaration) { + return declarationNameToString((declaration.parent).name); + } + if (!context.encounteredError && !(context.flags & NodeBuilderFlags.allowAnonymousIdentifier)) { + context.encounteredError = true; + } + switch (declaration.kind) { + case SyntaxKind.ClassExpression: + return "(Anonymous class)"; + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrowFunction: + return "(Anonymous function)"; + } + } + return symbol.name; + } + } + } + function typePredicateToString(typePredicate: TypePredicate, enclosingDeclaration?: Declaration, flags?: TypeFormatFlags): string { const writer = getSingleLineStringWriter(); getSymbolDisplayBuilder().buildTypePredicateDisplay(typePredicate, writer, enclosingDeclaration, flags); @@ -2466,6 +3130,7 @@ namespace ts { } } + function writeTypeList(types: Type[], delimiter: SyntaxKind) { for (let i = 0; i < types.length; i++) { if (i > 0) { @@ -2779,23 +3444,23 @@ namespace ts { function buildParameterDisplay(p: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) { const parameterNode = p.valueDeclaration; - if (isRestParameter(parameterNode)) { + if (parameterNode ? isRestParameter(parameterNode) : isTransientSymbol(p) && p.isRestParameter) { writePunctuation(writer, SyntaxKind.DotDotDotToken); } - if (isBindingPattern(parameterNode.name)) { + if (parameterNode && isBindingPattern(parameterNode.name)) { buildBindingPatternDisplay(parameterNode.name, writer, enclosingDeclaration, flags, symbolStack); } else { appendSymbolNameOnly(p, writer); } - if (isOptionalParameter(parameterNode)) { + if (parameterNode && isOptionalParameter(parameterNode)) { writePunctuation(writer, SyntaxKind.QuestionToken); } writePunctuation(writer, SyntaxKind.ColonToken); writeSpace(writer); let type = getTypeOfSymbol(p); - if (isRequiredInitializedParameter(parameterNode)) { + if (parameterNode && isRequiredInitializedParameter(parameterNode)) { type = includeFalsyTypes(type, TypeFlags.Undefined); } buildTypeDisplay(type, writer, enclosingDeclaration, flags, symbolStack); @@ -3785,7 +4450,7 @@ namespace ts { function getTypeOfFuncClassEnumModule(symbol: Symbol): Type { const links = getSymbolLinks(symbol); if (!links.type) { - if (symbol.flags & SymbolFlags.Module && isUntypedOrShorthandAmbientModuleSymbol(symbol)) { + if (symbol.flags & SymbolFlags.Module && isShorthandAmbientModuleSymbol(symbol)) { links.type = anyType; } else { @@ -3830,14 +4495,22 @@ namespace ts { function getTypeOfInstantiatedSymbol(symbol: Symbol): Type { const links = getSymbolLinks(symbol); if (!links.type) { - if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) { - return unknownType; + if (symbolInstantiationDepth === 100) { + error(symbol.valueDeclaration, Diagnostics.Generic_type_instantiation_is_excessively_deep_and_possibly_infinite); + links.type = unknownType; } - let type = instantiateType(getTypeOfSymbol(links.target), links.mapper); - if (!popTypeResolution()) { - type = reportCircularityError(symbol); + else { + if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) { + return unknownType; + } + symbolInstantiationDepth++; + let type = instantiateType(getTypeOfSymbol(links.target), links.mapper); + symbolInstantiationDepth--; + if (!popTypeResolution()) { + type = reportCircularityError(symbol); + } + links.type = type; } - links.type = type; } return links.type; } @@ -3993,14 +4666,15 @@ namespace ts { return getClassExtendsHeritageClauseElement(type.symbol.valueDeclaration); } - function getConstructorsForTypeArguments(type: Type, typeArgumentNodes: TypeNode[]): Signature[] { + function getConstructorsForTypeArguments(type: Type, typeArgumentNodes: TypeNode[], location: Node): Signature[] { const typeArgCount = length(typeArgumentNodes); + const isJavaScript = isInJavaScriptFile(location); return filter(getSignaturesOfType(type, SignatureKind.Construct), - sig => typeArgCount >= getMinTypeArgumentCount(sig.typeParameters) && typeArgCount <= length(sig.typeParameters)); + sig => (isJavaScript || typeArgCount >= getMinTypeArgumentCount(sig.typeParameters)) && typeArgCount <= length(sig.typeParameters)); } - function getInstantiatedConstructorsForTypeArguments(type: Type, typeArgumentNodes: TypeNode[]): Signature[] { - let signatures = getConstructorsForTypeArguments(type, typeArgumentNodes); + function getInstantiatedConstructorsForTypeArguments(type: Type, typeArgumentNodes: TypeNode[], location: Node): Signature[] { + let signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location); if (typeArgumentNodes) { const typeArguments = map(typeArgumentNodes, getTypeFromTypeNode); signatures = map(signatures, sig => getSignatureInstantiation(sig, typeArguments)); @@ -4012,7 +4686,8 @@ namespace ts { * The base constructor of a class can resolve to * * undefinedType if the class has no extends clause, * * unknownType if an error occurred during resolution of the extends expression, - * * nullType if the extends expression is the null value, or + * * nullType if the extends expression is the null value, + * * anyType if the extends expression has type any, or * * an object type with at least one construct signature. */ function getBaseConstructorTypeOfClass(type: InterfaceType): Type { @@ -4034,7 +4709,7 @@ namespace ts { error(type.symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol)); return type.resolvedBaseConstructorType = unknownType; } - if (baseConstructorType !== unknownType && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) { + if (!(baseConstructorType.flags & TypeFlags.Any) && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) { error(baseTypeNode.expression, Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType)); return type.resolvedBaseConstructorType = unknownType; } @@ -4066,7 +4741,7 @@ namespace ts { function resolveBaseTypesOfClass(type: InterfaceType): void { type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray; const baseConstructorType = getApparentType(getBaseConstructorTypeOfClass(type)); - if (!(baseConstructorType.flags & (TypeFlags.Object | TypeFlags.Intersection))) { + if (!(baseConstructorType.flags & (TypeFlags.Object | TypeFlags.Intersection | TypeFlags.Any))) { return; } const baseTypeNode = getBaseTypeNodeOfClass(type); @@ -4079,11 +4754,14 @@ namespace ts { // type arguments in the same manner as a type reference to get the same error reporting experience. baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol); } + else if (baseConstructorType.flags & TypeFlags.Any) { + baseType = baseConstructorType; + } else { // The class derives from a "class-like" constructor function, check that we have at least one construct signature // with a matching number of type parameters and use the return type of the first instantiated signature. Elsewhere // we check that all instantiated signatures return the same type. - const constructors = getInstantiatedConstructorsForTypeArguments(baseConstructorType, baseTypeNode.typeArguments); + const constructors = getInstantiatedConstructorsForTypeArguments(baseConstructorType, baseTypeNode.typeArguments, baseTypeNode); if (!constructors.length) { error(baseTypeNode.expression, Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments); return; @@ -4132,10 +4810,10 @@ namespace ts { return true; } - // A valid base type is any non-generic object type or intersection of non-generic + // A valid base type is `any`, any non-generic object type or intersection of non-generic // object types. function isValidBaseType(type: Type): boolean { - return type.flags & (TypeFlags.Object | TypeFlags.NonPrimitive) && !isGenericMappedType(type) || + return type.flags & (TypeFlags.Object | TypeFlags.NonPrimitive | TypeFlags.Any) && !isGenericMappedType(type) || type.flags & TypeFlags.Intersection && !forEach((type).types, t => !isValidBaseType(t)); } @@ -4547,7 +5225,11 @@ namespace ts { addInheritedMembers(members, getPropertiesOfType(instantiatedBaseType)); callSignatures = concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Call)); constructSignatures = concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Construct)); - stringIndexInfo = stringIndexInfo || getIndexInfoOfType(instantiatedBaseType, IndexKind.String); + if (!stringIndexInfo) { + stringIndexInfo = instantiatedBaseType === anyType ? + createIndexInfo(anyType, /*isReadonly*/ false) : + getIndexInfoOfType(instantiatedBaseType, IndexKind.String); + } numberIndexInfo = numberIndexInfo || getIndexInfoOfType(instantiatedBaseType, IndexKind.Number); } } @@ -4593,14 +5275,15 @@ namespace ts { return [createSignature(undefined, classType.localTypeParameters, undefined, emptyArray, classType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false)]; } const baseTypeNode = getBaseTypeNodeOfClass(classType); + const isJavaScript = isInJavaScriptFile(baseTypeNode); const typeArguments = map(baseTypeNode.typeArguments, getTypeFromTypeNode); const typeArgCount = length(typeArguments); const result: Signature[] = []; for (const baseSig of baseSignatures) { const minTypeArgumentCount = getMinTypeArgumentCount(baseSig.typeParameters); const typeParamCount = length(baseSig.typeParameters); - if (typeArgCount >= minTypeArgumentCount && typeArgCount <= typeParamCount) { - const sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount)) : cloneSignature(baseSig); + if ((isJavaScript || typeArgCount >= minTypeArgumentCount) && typeArgCount <= typeParamCount) { + const sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount, baseTypeNode)) : cloneSignature(baseSig); sig.typeParameters = classType.localTypeParameters; sig.resolvedReturnType = classType; result.push(sig); @@ -4788,6 +5471,7 @@ namespace ts { // Combinations of function, class, enum and module let members = emptySymbols; let constructSignatures: Signature[] = emptyArray; + let stringIndexInfo: IndexInfo = undefined; if (symbol.exports) { members = getExportsOfSymbol(symbol); } @@ -4802,9 +5486,12 @@ namespace ts { members = createSymbolTable(getNamedMembers(members)); addInheritedMembers(members, getPropertiesOfType(baseConstructorType)); } + else if (baseConstructorType === anyType) { + stringIndexInfo = createIndexInfo(anyType, /*isReadonly*/ false); + } } const numberIndexInfo = symbol.flags & SymbolFlags.Enum ? enumNumberIndexInfo : undefined; - setStructuredTypeMembers(type, members, emptyArray, constructSignatures, undefined, numberIndexInfo); + setStructuredTypeMembers(type, members, emptyArray, constructSignatures, stringIndexInfo, numberIndexInfo); // We resolve the members before computing the signatures because a signature may use // typeof with a qualified name expression that circularly references the type we are // in the process of resolving (see issue #6072). The temporarily empty signature list @@ -4957,7 +5644,8 @@ namespace ts { } /** If the given type is an object type and that type has a property by the given name, - * return the symbol for that property. Otherwise return undefined. */ + * return the symbol for that property. Otherwise return undefined. + */ function getPropertyOfObjectType(type: Type, name: string): Symbol { if (type.flags & TypeFlags.Object) { const resolved = resolveStructuredTypeMembers(type); @@ -5433,11 +6121,12 @@ namespace ts { * @param typeParameters The requested type parameters. * @param minTypeArgumentCount The minimum number of required type arguments. */ - function fillMissingTypeArguments(typeArguments: Type[] | undefined, typeParameters: TypeParameter[] | undefined, minTypeArgumentCount: number) { + function fillMissingTypeArguments(typeArguments: Type[] | undefined, typeParameters: TypeParameter[] | undefined, minTypeArgumentCount: number, location?: Node) { const numTypeParameters = length(typeParameters); if (numTypeParameters) { const numTypeArguments = length(typeArguments); - if (numTypeArguments >= minTypeArgumentCount && numTypeArguments <= numTypeParameters) { + const isJavaScript = isInJavaScriptFile(location); + if ((isJavaScript || numTypeArguments >= minTypeArgumentCount) && numTypeArguments <= numTypeParameters) { if (!typeArguments) { typeArguments = []; } @@ -5446,12 +6135,12 @@ namespace ts { // If a type parameter does not have a default type, or if the default type // is a forward reference, the empty object type is used. for (let i = numTypeArguments; i < numTypeParameters; i++) { - typeArguments[i] = emptyObjectType; + typeArguments[i] = isJavaScript ? anyType : emptyObjectType; } for (let i = numTypeArguments; i < numTypeParameters; i++) { const mapper = createTypeMapper(typeParameters, typeArguments); const defaultType = getDefaultFromTypeParameter(typeParameters[i]); - typeArguments[i] = defaultType ? instantiateType(defaultType, mapper) : emptyObjectType; + typeArguments[i] = defaultType ? instantiateType(defaultType, mapper) : isJavaScript ? anyType : emptyObjectType; } } } @@ -5561,6 +6250,37 @@ namespace ts { } } + function containsArgumentsReference(declaration: FunctionLikeDeclaration): boolean { + const links = getNodeLinks(declaration); + if (links.containsArgumentsReference === undefined) { + if (links.flags & NodeCheckFlags.CaptureArguments) { + links.containsArgumentsReference = true; + } + else { + links.containsArgumentsReference = traverse(declaration.body); + } + } + return links.containsArgumentsReference; + + function traverse(node: Node): boolean { + if (!node) return false; + switch (node.kind) { + case SyntaxKind.Identifier: + return (node).text === "arguments" && isPartOfExpression(node); + + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + return (node).name.kind === SyntaxKind.ComputedPropertyName + && traverse((node).name); + + default: + return !nodeStartsNewLexicalEnvironment(node) && !isPartOfTypeNode(node) && forEachChild(node, traverse); + } + } + } + function getSignaturesOfSymbol(symbol: Symbol): Signature[] { if (!symbol) return emptyArray; const result: Signature[] = []; @@ -5825,7 +6545,7 @@ namespace ts { if (typeParameters) { const numTypeArguments = length(node.typeArguments); const minTypeArgumentCount = getMinTypeArgumentCount(typeParameters); - if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) { + if (!isInJavaScriptFile(node) && (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length)) { error(node, minTypeArgumentCount === typeParameters.length ? Diagnostics.Generic_type_0_requires_1_type_argument_s @@ -5838,7 +6558,7 @@ namespace ts { // In a type reference, the outer type parameters of the referenced class or interface are automatically // supplied as type arguments and the type reference only specifies arguments for the local type parameters // of the class or interface. - const typeArguments = concatenate(type.outerTypeParameters, fillMissingTypeArguments(map(node.typeArguments, getTypeFromTypeNode), typeParameters, minTypeArgumentCount)); + const typeArguments = concatenate(type.outerTypeParameters, fillMissingTypeArguments(map(node.typeArguments, getTypeFromTypeNode), typeParameters, minTypeArgumentCount, node)); return createTypeReference(type, typeArguments); } if (node.typeArguments) { @@ -6243,6 +6963,8 @@ namespace ts { containsString?: boolean; containsNumber?: boolean; containsStringOrNumberLiteral?: boolean; + containsObjectType?: boolean; + containsEmptyObject?: boolean; unionIndex?: number; } @@ -6438,7 +7160,13 @@ namespace ts { else if (type.flags & TypeFlags.Any) { typeSet.containsAny = true; } + else if (getObjectFlags(type) & ObjectFlags.Anonymous && isEmptyObjectType(type)) { + typeSet.containsEmptyObject = true; + } else if (!(type.flags & TypeFlags.Never) && (strictNullChecks || !(type.flags & TypeFlags.Nullable)) && !contains(typeSet, type)) { + if (type.flags & TypeFlags.Object) { + typeSet.containsObjectType = true; + } if (type.flags & TypeFlags.Union && typeSet.unionIndex === undefined) { typeSet.unionIndex = typeSet.length; } @@ -6476,6 +7204,9 @@ namespace ts { if (typeSet.containsAny) { return anyType; } + if (typeSet.containsEmptyObject && !typeSet.containsObjectType) { + typeSet.push(emptyObjectType); + } if (typeSet.length === 1) { return typeSet[0]; } @@ -6613,8 +7344,9 @@ namespace ts { else { error(indexNode, Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType)); } + return unknownType; } - return unknownType; + return anyType; } function getIndexedAccessForMappedType(type: MappedType, indexType: Type, accessNode?: ElementAccessExpression | IndexedAccessTypeNode) { @@ -7645,6 +8377,18 @@ namespace ts { } } + function isEmptyResolvedType(t: ResolvedType) { + return t.properties.length === 0 && + t.callSignatures.length === 0 && + t.constructSignatures.length === 0 && + !t.stringIndexInfo && + !t.numberIndexInfo; + } + + function isEmptyObjectType(type: Type) { + return type.flags & TypeFlags.Object && isEmptyResolvedType(resolveStructuredTypeMembers(type)); + } + function isEnumTypeRelatedTo(source: EnumType, target: EnumType, errorReporter?: ErrorReporter) { if (source === target) { return true; @@ -7863,159 +8607,60 @@ namespace ts { // Above we check for excess properties with respect to the entire target type. When union // and intersection types are further deconstructed on the target side, we don't want to // make the check again (as it might fail for a partial target type). Therefore we obtain - // the regular source type and proceed with that. - if (isUnionOrIntersectionTypeWithoutNullableConstituents(target)) { - source = getRegularTypeOfObjectLiteral(source); - } - } - - const saveErrorInfo = errorInfo; - - // Note that these checks are specifically ordered to produce correct results. In particular, - // we need to deconstruct unions before intersections (because unions are always at the top), - // and we need to handle "each" relations before "some" relations for the same kind of type. - if (source.flags & TypeFlags.Union) { - if (relation === comparableRelation) { - result = someTypeRelatedToType(source as UnionType, target, reportErrors && !(source.flags & TypeFlags.Primitive)); - } - else { - result = eachTypeRelatedToType(source as UnionType, target, reportErrors && !(source.flags & TypeFlags.Primitive)); - } - if (result) { - return result; - } - } - else if (target.flags & TypeFlags.Union) { - if (result = typeRelatedToSomeType(source, target, reportErrors && !(source.flags & TypeFlags.Primitive) && !(target.flags & TypeFlags.Primitive))) { - return result; - } - } - else if (target.flags & TypeFlags.Intersection) { - if (result = typeRelatedToEachType(source, target as IntersectionType, reportErrors)) { - return result; - } - } - else if (source.flags & TypeFlags.Intersection) { - // Check to see if any constituents of the intersection are immediately related to the target. - // - // Don't report errors though. Checking whether a constituent is related to the source is not actually - // useful and leads to some confusing error messages. Instead it is better to let the below checks - // take care of this, or to not elaborate at all. For instance, - // - // - For an object type (such as 'C = A & B'), users are usually more interested in structural errors. - // - // - For a union type (such as '(A | B) = (C & D)'), it's better to hold onto the whole intersection - // than to report that 'D' is not assignable to 'A' or 'B'. - // - // - For a primitive type or type parameter (such as 'number = A & B') there is no point in - // breaking the intersection apart. - if (result = someTypeRelatedToType(source, target, /*reportErrors*/ false)) { - return result; - } - } - else if (target.flags & TypeFlags.TypeParameter) { - // A source type { [P in keyof T]: X } is related to a target type T if X is related to T[P]. - if (getObjectFlags(source) & ObjectFlags.Mapped && getConstraintTypeFromMappedType(source) === getIndexType(target)) { - if (!(source).declaration.questionToken) { - const templateType = getTemplateTypeFromMappedType(source); - const indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(source)); - if (result = isRelatedTo(templateType, indexedAccessType, reportErrors)) { - return result; - } - } - } - } - else if (target.flags & TypeFlags.Index) { - // A keyof S is related to a keyof T if T is related to S. - if (source.flags & TypeFlags.Index) { - if (result = isRelatedTo((target).type, (source).type, /*reportErrors*/ false)) { - return result; - } - } - // A type S is assignable to keyof T if S is assignable to keyof C, where C is the - // constraint of T. - const constraint = getConstraintOfType((target).type); - if (constraint) { - if (result = isRelatedTo(source, getIndexType(constraint), reportErrors)) { - return result; - } - } - } - else if (target.flags & TypeFlags.IndexedAccess) { - // if we have indexed access types with identical index types, see if relationship holds for - // the two object types. - if (source.flags & TypeFlags.IndexedAccess && (source).indexType === (target).indexType) { - if (result = isRelatedTo((source).objectType, (target).objectType, reportErrors)) { - return result; - } - } - // A type S is related to a type T[K] if S is related to A[K], where K is string-like and - // A is the apparent type of S. - const constraint = getBaseConstraintOfType(target); - if (constraint) { - if (result = isRelatedTo(source, constraint, reportErrors)) { - errorInfo = saveErrorInfo; - return result; - } + // the regular source type and proceed with that. + if (isUnionOrIntersectionTypeWithoutNullableConstituents(target)) { + source = getRegularTypeOfObjectLiteral(source); } } - if (source.flags & TypeFlags.TypeParameter) { - // A source type T is related to a target type { [P in keyof T]: X } if T[P] is related to X. - if (getObjectFlags(target) & ObjectFlags.Mapped && getConstraintTypeFromMappedType(target) === getIndexType(source)) { - const indexedAccessType = getIndexedAccessType(source, getTypeParameterFromMappedType(target)); - const templateType = getTemplateTypeFromMappedType(target); - if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) { - errorInfo = saveErrorInfo; - return result; - } + const saveErrorInfo = errorInfo; + + // Note that these checks are specifically ordered to produce correct results. In particular, + // we need to deconstruct unions before intersections (because unions are always at the top), + // and we need to handle "each" relations before "some" relations for the same kind of type. + if (source.flags & TypeFlags.Union) { + if (relation === comparableRelation) { + result = someTypeRelatedToType(source as UnionType, target, reportErrors && !(source.flags & TypeFlags.Primitive)); } else { - let constraint = getConstraintOfTypeParameter(source); - // A type parameter with no constraint is not related to the non-primitive object type. - if (constraint || !(target.flags & TypeFlags.NonPrimitive)) { - if (!constraint || constraint.flags & TypeFlags.Any) { - constraint = emptyObjectType; - } - // The constraint may need to be further instantiated with its 'this' type. - constraint = getTypeWithThisArgument(constraint, source); - // Report constraint errors only if the constraint is not the empty object type - const reportConstraintErrors = reportErrors && constraint !== emptyObjectType; - if (result = isRelatedTo(constraint, target, reportConstraintErrors)) { - errorInfo = saveErrorInfo; - return result; - } - } + result = eachTypeRelatedToType(source as UnionType, target, reportErrors && !(source.flags & TypeFlags.Primitive)); + } + if (result) { + return result; } } - else if (source.flags & TypeFlags.IndexedAccess) { - // A type S[K] is related to a type T if A[K] is related to T, where K is string-like and - // A is the apparent type of S. - const constraint = getConstraintOfType(source); - if (constraint) { - if (result = isRelatedTo(constraint, target, reportErrors)) { - errorInfo = saveErrorInfo; + else { + if (target.flags & TypeFlags.Union) { + if (result = typeRelatedToSomeType(source, target, reportErrors && !(source.flags & TypeFlags.Primitive) && !(target.flags & TypeFlags.Primitive))) { return result; } } - } - else { - if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (source).target === (target).target) { - // We have type references to same target type, see if relationship holds for all type arguments - if (result = typeArgumentsRelatedTo(source, target, reportErrors)) { + else if (target.flags & TypeFlags.Intersection) { + if (result = typeRelatedToEachType(source, target as IntersectionType, reportErrors)) { return result; } } - // Even if relationship doesn't hold for unions, intersections, or generic type references, - // it may hold in a structural comparison. - const apparentSource = getApparentType(source); - // In a check of the form X = A & B, we will have previously checked if A relates to X or B relates - // to X. Failing both of those we want to check if the aggregation of A and B's members structurally - // relates to X. Thus, we include intersection types on the source side here. - if (apparentSource.flags & (TypeFlags.Object | TypeFlags.Intersection) && target.flags & TypeFlags.Object) { - // Report structural errors only if we haven't reported any errors yet - const reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo && !(source.flags & TypeFlags.Primitive); - if (result = objectTypeRelatedTo(apparentSource, source, target, reportStructuralErrors)) { + else if (source.flags & TypeFlags.Intersection) { + // Check to see if any constituents of the intersection are immediately related to the target. + // + // Don't report errors though. Checking whether a constituent is related to the source is not actually + // useful and leads to some confusing error messages. Instead it is better to let the below checks + // take care of this, or to not elaborate at all. For instance, + // + // - For an object type (such as 'C = A & B'), users are usually more interested in structural errors. + // + // - For a union type (such as '(A | B) = (C & D)'), it's better to hold onto the whole intersection + // than to report that 'D' is not assignable to 'A' or 'B'. + // + // - For a primitive type or type parameter (such as 'number = A & B') there is no point in + // breaking the intersection apart. + if (result = someTypeRelatedToType(source, target, /*reportErrors*/ false)) { + return result; + } + } + + if (source.flags & TypeFlags.StructuredOrTypeVariable || target.flags & TypeFlags.StructuredOrTypeVariable) { + if (result = recursiveTypeRelatedTo(source, target, reportErrors)) { errorInfo = saveErrorInfo; return result; } @@ -8037,13 +8682,7 @@ namespace ts { function isIdenticalTo(source: Type, target: Type): Ternary { let result: Ternary; if (source.flags & TypeFlags.Object && target.flags & TypeFlags.Object) { - if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (source).target === (target).target) { - // We have type references to same target type, see if all type arguments are identical - if (result = typeArgumentsRelatedTo(source, target, /*reportErrors*/ false)) { - return result; - } - } - return objectTypeRelatedTo(source, source, target, /*reportErrors*/ false); + return recursiveTypeRelatedTo(source, target, /*reportErrors*/ false); } if (source.flags & TypeFlags.Union && target.flags & TypeFlags.Union || source.flags & TypeFlags.Intersection && target.flags & TypeFlags.Intersection) { @@ -8085,18 +8724,6 @@ namespace ts { return false; } - function isEmptyResolvedType(t: ResolvedType) { - return t.properties.length === 0 && - t.callSignatures.length === 0 && - t.constructSignatures.length === 0 && - !t.stringIndexInfo && - !t.numberIndexInfo; - } - - function isEmptyObjectType(type: Type) { - return type.flags & TypeFlags.Object && isEmptyResolvedType(resolveStructuredTypeMembers(type)); - } - function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean { if (maybeTypeOfKind(target, TypeFlags.Object) && !(getObjectFlags(target) & ObjectFlags.ObjectLiteralPatternWithComputedProperties)) { const isComparingJsxAttributes = !!(source.flags & TypeFlags.JsxAttributes); @@ -8232,12 +8859,12 @@ namespace ts { return result; } - // Determine if two object types are related by structure. First, check if the result is already available in the global cache. + // Determine if possibly recursive types are related. First, check if the result is already available in the global cache. // Second, check if we have already started a comparison of the given two types in which case we assume the result to be true. // Third, check if both types are part of deeply nested chains of generic type instantiations and if so assume the types are // equal and infinitely expanding. Fourth, if we have reached a depth of 100 nested comparisons, assume we have runaway recursion // and issue an error. Otherwise, actually compare the structure of the two types. - function objectTypeRelatedTo(source: Type, originalSource: Type, target: Type, reportErrors: boolean): Ternary { + function recursiveTypeRelatedTo(source: Type, target: Type, reportErrors: boolean): Ternary { if (overflow) { return Ternary.False; } @@ -8279,28 +8906,7 @@ namespace ts { const saveExpandingFlags = expandingFlags; if (!(expandingFlags & 1) && isDeeplyNestedType(source, sourceStack, depth)) expandingFlags |= 1; if (!(expandingFlags & 2) && isDeeplyNestedType(target, targetStack, depth)) expandingFlags |= 2; - let result: Ternary; - if (expandingFlags === 3) { - result = Ternary.Maybe; - } - else if (isGenericMappedType(source) || isGenericMappedType(target)) { - result = mappedTypeRelatedTo(source, target, reportErrors); - } - else { - result = propertiesRelatedTo(source, target, reportErrors); - if (result) { - result &= signaturesRelatedTo(source, target, SignatureKind.Call, reportErrors); - if (result) { - result &= signaturesRelatedTo(source, target, SignatureKind.Construct, reportErrors); - if (result) { - result &= indexTypesRelatedTo(source, originalSource, target, IndexKind.String, reportErrors); - if (result) { - result &= indexTypesRelatedTo(source, originalSource, target, IndexKind.Number, reportErrors); - } - } - } - } - } + const result = expandingFlags !== 3 ? structuredTypeRelatedTo(source, target, reportErrors) : Ternary.Maybe; expandingFlags = saveExpandingFlags; depth--; if (result) { @@ -8317,6 +8923,141 @@ namespace ts { return result; } + function structuredTypeRelatedTo(source: Type, target: Type, reportErrors: boolean): Ternary { + let result: Ternary; + const saveErrorInfo = errorInfo; + if (target.flags & TypeFlags.TypeParameter) { + // A source type { [P in keyof T]: X } is related to a target type T if X is related to T[P]. + if (getObjectFlags(source) & ObjectFlags.Mapped && getConstraintTypeFromMappedType(source) === getIndexType(target)) { + if (!(source).declaration.questionToken) { + const templateType = getTemplateTypeFromMappedType(source); + const indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(source)); + if (result = isRelatedTo(templateType, indexedAccessType, reportErrors)) { + return result; + } + } + } + } + else if (target.flags & TypeFlags.Index) { + // A keyof S is related to a keyof T if T is related to S. + if (source.flags & TypeFlags.Index) { + if (result = isRelatedTo((target).type, (source).type, /*reportErrors*/ false)) { + return result; + } + } + // A type S is assignable to keyof T if S is assignable to keyof C, where C is the + // constraint of T. + const constraint = getConstraintOfType((target).type); + if (constraint) { + if (result = isRelatedTo(source, getIndexType(constraint), reportErrors)) { + return result; + } + } + } + else if (target.flags & TypeFlags.IndexedAccess) { + // A type S is related to a type T[K] if S is related to A[K], where K is string-like and + // A is the apparent type of S. + const constraint = getConstraintOfType(target); + if (constraint) { + if (result = isRelatedTo(source, constraint, reportErrors)) { + errorInfo = saveErrorInfo; + return result; + } + } + } + + if (source.flags & TypeFlags.TypeParameter) { + // A source type T is related to a target type { [P in keyof T]: X } if T[P] is related to X. + if (getObjectFlags(target) & ObjectFlags.Mapped && getConstraintTypeFromMappedType(target) === getIndexType(source)) { + const indexedAccessType = getIndexedAccessType(source, getTypeParameterFromMappedType(target)); + const templateType = getTemplateTypeFromMappedType(target); + if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) { + errorInfo = saveErrorInfo; + return result; + } + } + else { + let constraint = getConstraintOfTypeParameter(source); + // A type parameter with no constraint is not related to the non-primitive object type. + if (constraint || !(target.flags & TypeFlags.NonPrimitive)) { + if (!constraint || constraint.flags & TypeFlags.Any) { + constraint = emptyObjectType; + } + // The constraint may need to be further instantiated with its 'this' type. + constraint = getTypeWithThisArgument(constraint, source); + // Report constraint errors only if the constraint is not the empty object type + const reportConstraintErrors = reportErrors && constraint !== emptyObjectType; + if (result = isRelatedTo(constraint, target, reportConstraintErrors)) { + errorInfo = saveErrorInfo; + return result; + } + } + } + } + else if (source.flags & TypeFlags.IndexedAccess) { + // A type S[K] is related to a type T if A[K] is related to T, where K is string-like and + // A is the apparent type of S. + const constraint = getConstraintOfType(source); + if (constraint) { + if (result = isRelatedTo(constraint, target, reportErrors)) { + errorInfo = saveErrorInfo; + return result; + } + } + else if (target.flags & TypeFlags.IndexedAccess && (source).indexType === (target).indexType) { + // if we have indexed access types with identical index types, see if relationship holds for + // the two object types. + if (result = isRelatedTo((source).objectType, (target).objectType, reportErrors)) { + return result; + } + } + } + else { + if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (source).target === (target).target) { + // We have type references to same target type, see if relationship holds for all type arguments + if (result = typeArgumentsRelatedTo(source, target, reportErrors)) { + return result; + } + } + // Even if relationship doesn't hold for unions, intersections, or generic type references, + // it may hold in a structural comparison. + const sourceIsPrimitive = !!(source.flags & TypeFlags.Primitive); + if (relation !== identityRelation) { + source = getApparentType(source); + } + // In a check of the form X = A & B, we will have previously checked if A relates to X or B relates + // to X. Failing both of those we want to check if the aggregation of A and B's members structurally + // relates to X. Thus, we include intersection types on the source side here. + if (source.flags & (TypeFlags.Object | TypeFlags.Intersection) && target.flags & TypeFlags.Object) { + // Report structural errors only if we haven't reported any errors yet + const reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo && !sourceIsPrimitive; + if (isGenericMappedType(source) || isGenericMappedType(target)) { + result = mappedTypeRelatedTo(source, target, reportStructuralErrors); + } + else { + result = propertiesRelatedTo(source, target, reportStructuralErrors); + if (result) { + result &= signaturesRelatedTo(source, target, SignatureKind.Call, reportStructuralErrors); + if (result) { + result &= signaturesRelatedTo(source, target, SignatureKind.Construct, reportStructuralErrors); + if (result) { + result &= indexTypesRelatedTo(source, target, IndexKind.String, sourceIsPrimitive, reportStructuralErrors); + if (result) { + result &= indexTypesRelatedTo(source, target, IndexKind.Number, sourceIsPrimitive, reportStructuralErrors); + } + } + } + } + } + if (result) { + errorInfo = saveErrorInfo; + return result; + } + } + } + return Ternary.False; + } + // A type [P in S]: X is related to a type [Q in T]: Y if T is related to S and X' is // related to Y, where X' is an instantiation of X in which P is replaced with Q. Notice // that S and T are contra-variant whereas X and Y are co-variant. @@ -8565,12 +9306,12 @@ namespace ts { return related; } - function indexTypesRelatedTo(source: Type, originalSource: Type, target: Type, kind: IndexKind, reportErrors: boolean) { + function indexTypesRelatedTo(source: Type, target: Type, kind: IndexKind, sourceIsPrimitive: boolean, reportErrors: boolean) { if (relation === identityRelation) { return indexTypesIdenticalTo(source, target, kind); } const targetInfo = getIndexInfoOfType(target, kind); - if (!targetInfo || ((targetInfo.type.flags & TypeFlags.Any) && !(originalSource.flags & TypeFlags.Primitive))) { + if (!targetInfo || targetInfo.type.flags & TypeFlags.Any && !sourceIsPrimitive) { // Index signature of type any permits assignment from everything but primitives return Ternary.True; } @@ -9036,7 +9777,7 @@ namespace ts { const original = getTypeOfSymbol(property); const updated = f(original); members.set(property.name, updated === original ? property : createSymbolWithType(property, updated)); - }; + } return members; } @@ -9080,7 +9821,7 @@ namespace ts { // Since get accessors already widen their return value there is no need to // widen accessor based properties here. members.set(prop.name, prop.flags & SymbolFlags.Property ? getWidenedProperty(prop) : prop); - }; + } const stringIndexInfo = getIndexInfoOfType(type, IndexKind.String); const numberIndexInfo = getIndexInfoOfType(type, IndexKind.Number); return createAnonymousType(type.symbol, members, emptyArray, emptyArray, @@ -9738,6 +10479,8 @@ namespace ts { getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(source)) === getSymbolOfNode(target); case SyntaxKind.ThisKeyword: return target.kind === SyntaxKind.ThisKeyword; + case SyntaxKind.SuperKeyword: + return target.kind === SyntaxKind.SuperKeyword; case SyntaxKind.PropertyAccessExpression: return target.kind === SyntaxKind.PropertyAccessExpression && (source).name.text === (target).name.text && @@ -10874,6 +11617,7 @@ namespace ts { switch (expr.kind) { case SyntaxKind.Identifier: case SyntaxKind.ThisKeyword: + case SyntaxKind.SuperKeyword: case SyntaxKind.PropertyAccessExpression: return narrowTypeByTruthiness(type, expr, assumeTrue); case SyntaxKind.CallExpression: @@ -11004,9 +11748,7 @@ namespace ts { } } - if (node.flags & NodeFlags.AwaitContext) { - getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments; - } + getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments; return getTypeOfSymbol(symbol); } @@ -11346,8 +12088,8 @@ namespace ts { // If this is a function in a JS file, it might be a class method. Check if it's the RHS // of a x.prototype.y = function [name]() { .... } if (container.kind === SyntaxKind.FunctionExpression && - isInJavaScriptFile(container.parent) && - getSpecialPropertyAssignmentKind(container.parent) === SpecialPropertyAssignmentKind.PrototypeProperty) { + container.parent.kind === SyntaxKind.BinaryExpression && + getSpecialPropertyAssignmentKind(container.parent as BinaryExpression) === SpecialPropertyAssignmentKind.PrototypeProperty) { // Get the 'x' of 'x.prototype.y = f' (here, 'f' is 'container') const className = (((container.parent as BinaryExpression) // x.prototype.y = f .left as PropertyAccessExpression) // x.prototype.y @@ -12623,11 +13365,11 @@ namespace ts { } /** - * Looks up an intrinsic tag name and returns a symbol that either points to an intrinsic - * property (in which case nodeLinks.jsxFlags will be IntrinsicNamedElement) or an intrinsic - * string index signature (in which case nodeLinks.jsxFlags will be IntrinsicIndexedElement). - * May also return unknownSymbol if both of these lookups fail. - */ + * Looks up an intrinsic tag name and returns a symbol that either points to an intrinsic + * property (in which case nodeLinks.jsxFlags will be IntrinsicNamedElement) or an intrinsic + * string index signature (in which case nodeLinks.jsxFlags will be IntrinsicIndexedElement). + * May also return unknownSymbol if both of these lookups fail. + */ function getIntrinsicTagSymbol(node: JsxOpeningLikeElement | JsxClosingElement): Symbol { const links = getNodeLinks(node); if (!links.resolvedSymbol) { @@ -12831,7 +13573,7 @@ namespace ts { * @return attributes type if able to resolve the type of node * anyType if there is no type ElementAttributesProperty or there is an error * emptyObjectType if there is no "prop" in the element instance type - **/ + */ function resolveCustomJsxElementAttributesType(openingLikeElement: JsxOpeningLikeElement, shouldIncludeAllStatelessAttributesType: boolean, elementType?: Type, @@ -13088,11 +13830,11 @@ namespace ts { } /** - * Check whether the given attributes of JSX opening-like element is assignable to the tagName attributes. - * Get the attributes type of the opening-like element through resolving the tagName, "target attributes" - * Check assignablity between given attributes property, "source attributes", and the "target attributes" - * @param openingLikeElement an opening-like JSX element to check its JSXAttributes - */ + * Check whether the given attributes of JSX opening-like element is assignable to the tagName attributes. + * Get the attributes type of the opening-like element through resolving the tagName, "target attributes" + * Check assignablity between given attributes property, "source attributes", and the "target attributes" + * @param openingLikeElement an opening-like JSX element to check its JSXAttributes + */ function checkJsxAttributesAssignableToTagNameAttributes(openingLikeElement: JsxOpeningLikeElement) { // The function involves following steps: // 1. Figure out expected attributes type by resolving tagName of the JSX opening-like element, targetAttributesType. @@ -13959,18 +14701,18 @@ namespace ts { /** - * Returns the effective argument count for a node that works like a function invocation. - * If 'node' is a Decorator, the number of arguments is derived from the decoration - * target and the signature: - * If 'node.target' is a class declaration or class expression, the effective argument - * count is 1. - * If 'node.target' is a parameter declaration, the effective argument count is 3. - * If 'node.target' is a property declaration, the effective argument count is 2. - * If 'node.target' is a method or accessor declaration, the effective argument count - * is 3, although it can be 2 if the signature only accepts two arguments, allowing - * us to match a property decorator. - * Otherwise, the argument count is the length of the 'args' array. - */ + * Returns the effective argument count for a node that works like a function invocation. + * If 'node' is a Decorator, the number of arguments is derived from the decoration + * target and the signature: + * If 'node.target' is a class declaration or class expression, the effective argument + * count is 1. + * If 'node.target' is a parameter declaration, the effective argument count is 3. + * If 'node.target' is a property declaration, the effective argument count is 2. + * If 'node.target' is a method or accessor declaration, the effective argument count + * is 3, although it can be 2 if the signature only accepts two arguments, allowing + * us to match a property decorator. + * Otherwise, the argument count is the length of the 'args' array. + */ function getEffectiveArgumentCount(node: CallLikeExpression, args: Expression[], signature: Signature) { if (node.kind === SyntaxKind.Decorator) { switch (node.parent.kind) { @@ -14012,17 +14754,17 @@ namespace ts { } /** - * Returns the effective type of the first argument to a decorator. - * If 'node' is a class declaration or class expression, the effective argument type - * is the type of the static side of the class. - * If 'node' is a parameter declaration, the effective argument type is either the type - * of the static or instance side of the class for the parameter's parent method, - * depending on whether the method is declared static. - * For a constructor, the type is always the type of the static side of the class. - * If 'node' is a property, method, or accessor declaration, the effective argument - * type is the type of the static or instance side of the parent class for class - * element, depending on whether the element is declared static. - */ + * Returns the effective type of the first argument to a decorator. + * If 'node' is a class declaration or class expression, the effective argument type + * is the type of the static side of the class. + * If 'node' is a parameter declaration, the effective argument type is either the type + * of the static or instance side of the class for the parameter's parent method, + * depending on whether the method is declared static. + * For a constructor, the type is always the type of the static side of the class. + * If 'node' is a property, method, or accessor declaration, the effective argument + * type is the type of the static or instance side of the parent class for class + * element, depending on whether the element is declared static. + */ function getEffectiveDecoratorFirstArgumentType(node: Node): Type { // The first argument to a decorator is its `target`. if (node.kind === SyntaxKind.ClassDeclaration) { @@ -14058,20 +14800,20 @@ namespace ts { } /** - * Returns the effective type for the second argument to a decorator. - * If 'node' is a parameter, its effective argument type is one of the following: - * If 'node.parent' is a constructor, the effective argument type is 'any', as we - * will emit `undefined`. - * If 'node.parent' is a member with an identifier, numeric, or string literal name, - * the effective argument type will be a string literal type for the member name. - * If 'node.parent' is a computed property name, the effective argument type will - * either be a symbol type or the string type. - * If 'node' is a member with an identifier, numeric, or string literal name, the - * effective argument type will be a string literal type for the member name. - * If 'node' is a computed property name, the effective argument type will either - * be a symbol type or the string type. - * A class decorator does not have a second argument type. - */ + * Returns the effective type for the second argument to a decorator. + * If 'node' is a parameter, its effective argument type is one of the following: + * If 'node.parent' is a constructor, the effective argument type is 'any', as we + * will emit `undefined`. + * If 'node.parent' is a member with an identifier, numeric, or string literal name, + * the effective argument type will be a string literal type for the member name. + * If 'node.parent' is a computed property name, the effective argument type will + * either be a symbol type or the string type. + * If 'node' is a member with an identifier, numeric, or string literal name, the + * effective argument type will be a string literal type for the member name. + * If 'node' is a computed property name, the effective argument type will either + * be a symbol type or the string type. + * A class decorator does not have a second argument type. + */ function getEffectiveDecoratorSecondArgumentType(node: Node) { // The second argument to a decorator is its `propertyKey` if (node.kind === SyntaxKind.ClassDeclaration) { @@ -14125,12 +14867,12 @@ namespace ts { } /** - * Returns the effective argument type for the third argument to a decorator. - * If 'node' is a parameter, the effective argument type is the number type. - * If 'node' is a method or accessor, the effective argument type is a - * `TypedPropertyDescriptor` instantiated with the type of the member. - * Class and property decorators do not have a third effective argument. - */ + * Returns the effective argument type for the third argument to a decorator. + * If 'node' is a parameter, the effective argument type is the number type. + * If 'node' is a method or accessor, the effective argument type is a + * `TypedPropertyDescriptor` instantiated with the type of the member. + * Class and property decorators do not have a third effective argument. + */ function getEffectiveDecoratorThirdArgumentType(node: Node) { // The third argument to a decorator is either its `descriptor` for a method decorator // or its `parameterIndex` for a parameter decorator @@ -14163,8 +14905,8 @@ namespace ts { } /** - * Returns the effective argument type for the provided argument to a decorator. - */ + * Returns the effective argument type for the provided argument to a decorator. + */ function getEffectiveDecoratorArgumentType(node: Decorator, argIndex: number): Type { if (argIndex === 0) { return getEffectiveDecoratorFirstArgumentType(node.parent); @@ -14181,8 +14923,8 @@ namespace ts { } /** - * Gets the effective argument type for an argument in a call expression. - */ + * Gets the effective argument type for an argument in a call expression. + */ function getEffectiveArgumentType(node: CallLikeExpression, argIndex: number): Type { // Decorators provide special arguments, a tagged template expression provides // a special first argument, and string literals get string literal types @@ -14200,8 +14942,8 @@ namespace ts { } /** - * Gets the effective argument expression for an argument in a call expression. - */ + * Gets the effective argument expression for an argument in a call expression. + */ function getEffectiveArgument(node: CallLikeExpression, args: Expression[], argIndex: number) { // For a decorator or the first argument of a tagged template expression we return undefined. if (node.kind === SyntaxKind.Decorator || @@ -14213,8 +14955,8 @@ namespace ts { } /** - * Gets the error node to use when reporting errors for an effective argument. - */ + * Gets the error node to use when reporting errors for an effective argument. + */ function getEffectiveArgumentErrorNode(node: CallLikeExpression, argIndex: number, arg: Expression) { if (node.kind === SyntaxKind.Decorator) { // For a decorator, we use the expression of the decorator for error reporting. @@ -14245,6 +14987,21 @@ namespace ts { } } + if (signatures.length === 1) { + const declaration = signatures[0].declaration; + if (declaration && isInJavaScriptFile(declaration) && !hasJSDocParameterTags(declaration)) { + if (containsArgumentsReference(declaration)) { + const signatureWithRest = cloneSignature(signatures[0]); + const syntheticArgsSymbol = createSymbol(SymbolFlags.Variable, "args"); + syntheticArgsSymbol.type = anyArrayType; + syntheticArgsSymbol.isRestParameter = true; + signatureWithRest.parameters = concatenate(signatureWithRest.parameters, [syntheticArgsSymbol]); + signatureWithRest.hasRestParameter = true; + signatures = [signatureWithRest]; + } + } + } + const candidates = candidatesOutArray || []; // reorderCandidates fills up the candidates array directly reorderCandidates(signatures, candidates); @@ -14440,7 +15197,7 @@ namespace ts { if (!checkApplicableSignature(node, args, candidate, relation, excludeArgument, /*reportErrors*/ false)) { break; } - const index = excludeArgument ? indexOf(excludeArgument, true) : -1; + const index = excludeArgument ? indexOf(excludeArgument, /*value*/ true) : -1; if (index < 0) { return candidate; } @@ -14483,7 +15240,7 @@ namespace ts { // with the type arguments specified in the extends clause. const baseTypeNode = getClassExtendsHeritageClauseElement(getContainingClass(node)); if (baseTypeNode) { - const baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); + const baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode); return resolveCall(node, baseConstructors, candidatesOutArray); } } @@ -14701,8 +15458,8 @@ namespace ts { } /** - * Gets the localized diagnostic head message to use for errors when resolving a decorator as a call expression. - */ + * Gets the localized diagnostic head message to use for errors when resolving a decorator as a call expression. + */ function getDiagnosticHeadMessageForDecoratorResolution(node: Decorator) { switch (node.parent.kind) { case SyntaxKind.ClassDeclaration: @@ -14723,8 +15480,8 @@ namespace ts { } /** - * Resolves a decorator as if it were a call expression. - */ + * Resolves a decorator as if it were a call expression. + */ function resolveDecorator(node: Decorator, candidatesOutArray: Signature[]): Signature { const funcType = checkExpression(node.expression); const apparentType = getApparentType(funcType); @@ -15697,7 +16454,7 @@ namespace ts { if (!(isTypeComparableTo(leftType, stringType) || isTypeOfKind(leftType, TypeFlags.NumberLike | TypeFlags.ESSymbol))) { error(left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol); } - if (!isTypeAnyOrAllConstituentTypesHaveKind(rightType, TypeFlags.Object | TypeFlags.TypeVariable)) { + if (!isTypeAnyOrAllConstituentTypesHaveKind(rightType, TypeFlags.Object | TypeFlags.TypeVariable | TypeFlags.NonPrimitive)) { error(right, Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); } return booleanType; @@ -17532,10 +18289,10 @@ namespace ts { } /** - * Gets the "promised type" of a promise. - * @param type The type of the promise. - * @remarks The "promised type" of a type is the type of the "value" parameter of the "onfulfilled" callback. - */ + * Gets the "promised type" of a promise. + * @param type The type of the promise. + * @remarks The "promised type" of a type is the type of the "value" parameter of the "onfulfilled" callback. + */ function getPromisedTypeOfPromise(promise: Type, errorNode?: Node): Type { // // { // promise @@ -17590,12 +18347,12 @@ namespace ts { } /** - * Gets the "awaited type" of a type. - * @param type The type to await. - * @remarks The "awaited type" of an expression is its "promised type" if the expression is a - * Promise-like type; otherwise, it is the type of the expression. This is used to reflect - * The runtime behavior of the `await` keyword. - */ + * Gets the "awaited type" of a type. + * @param type The type to await. + * @remarks The "awaited type" of an expression is its "promised type" if the expression is a + * Promise-like type; otherwise, it is the type of the expression. This is used to reflect + * The runtime behavior of the `await` keyword. + */ function checkAwaitedType(type: Type, errorNode: Node): Type { return getAwaitedType(type, errorNode) || unknownType; } @@ -18068,7 +18825,7 @@ namespace ts { case SyntaxKind.ConstructorType: checkUnusedTypeParameters(node); break; - }; + } } } } @@ -19559,7 +20316,7 @@ namespace ts { } function checkClassLikeDeclaration(node: ClassLikeDeclaration) { - checkGrammarClassDeclarationHeritageClauses(node); + checkGrammarClassLikeDeclaration(node); checkDecorators(node); if (node.name) { checkTypeNameIsReserved(node.name, Diagnostics.Class_name_cannot_be_0); @@ -19597,7 +20354,7 @@ namespace ts { checkSourceElement(baseTypeNode.expression); if (baseTypeNode.typeArguments) { forEach(baseTypeNode.typeArguments, checkSourceElement); - for (const constructor of getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments)) { + for (const constructor of getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode)) { if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) { break; } @@ -19615,7 +20372,7 @@ namespace ts { // that all instantiated base constructor signatures return the same type. We can simply compare the type // references (as opposed to checking the structure of the types) because elsewhere we have already checked // that the base type is a class or interface type (and not, for example, an anonymous object type). - const constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); + const constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); if (forEach(constructors, sig => getReturnTypeOfSignature(sig) !== baseType)) { error(baseTypeNode.expression, Diagnostics.Base_constructors_must_all_have_the_same_return_type); } @@ -21058,7 +21815,7 @@ namespace ts { } function getSpecialPropertyAssignmentSymbolFromEntityName(entityName: EntityName | PropertyAccessExpression) { - const specialPropertyAssignmentKind = getSpecialPropertyAssignmentKind(entityName.parent.parent); + const specialPropertyAssignmentKind = getSpecialPropertyAssignmentKind(entityName.parent.parent as BinaryExpression); switch (specialPropertyAssignmentKind) { case SpecialPropertyAssignmentKind.ExportsProperty: case SpecialPropertyAssignmentKind.PrototypeProperty: @@ -21103,7 +21860,6 @@ namespace ts { if (isHeritageClauseElementIdentifier(entityName)) { let meaning = SymbolFlags.None; - // In an interface or class, we're definitely interested in a type. if (entityName.parent.kind === SyntaxKind.ExpressionWithTypeArguments) { meaning = SymbolFlags.Type; @@ -21118,9 +21874,13 @@ namespace ts { } meaning |= SymbolFlags.Alias; - return resolveEntityName(entityName, meaning); + const entityNameSymbol = resolveEntityName(entityName, meaning); + if (entityNameSymbol) { + return entityNameSymbol; + } } - else if (isPartOfExpression(entityName)) { + + if (isPartOfExpression(entityName)) { if (nodeIsMissing(entityName)) { // Missing entity name. return undefined; @@ -21395,9 +22155,9 @@ namespace ts { } /** - * Gets either the static or instance type of a class element, based on - * whether the element is declared as "static". - */ + * Gets either the static or instance type of a class element, based on + * whether the element is declared as "static". + */ function getParentTypeOfClassElement(node: ClassElement) { const classSymbol = getSymbolOfNode(node.parent); return getModifierFlags(node) & ModifierFlags.Static @@ -21469,7 +22229,7 @@ namespace ts { function moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean { let moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression); - if (!moduleSymbol || isUntypedOrShorthandAmbientModuleSymbol(moduleSymbol)) { + if (!moduleSymbol || isShorthandAmbientModuleSymbol(moduleSymbol)) { // If the module is not found or is shorthand, assume that it may export a value. return true; } @@ -22520,6 +23280,11 @@ namespace ts { checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file); } + function checkGrammarClassLikeDeclaration(node: ClassLikeDeclaration): boolean { + const file = getSourceFileOfNode(node); + return checkGrammarClassDeclarationHeritageClauses(node) || checkGrammarTypeParameterList(node.typeParameters, file); + } + function checkGrammarArrowFunction(node: FunctionLikeDeclaration, file: SourceFile): boolean { if (node.kind === SyntaxKind.ArrowFunction) { const arrowFunction = node; @@ -22914,9 +23679,9 @@ namespace ts { } /** Does the accessor have the right number of parameters? - - A get accessor has no parameters or a single `this` parameter. - A set accessor has one parameter or a `this` parameter and one more parameter */ + * A get accessor has no parameters or a single `this` parameter. + * A set accessor has one parameter or a `this` parameter and one more parameter. + */ function doesAccessorHaveCorrectParameterCount(accessor: AccessorDeclaration) { return getAccessorThisParameter(accessor) || accessor.parameters.length === (accessor.kind === SyntaxKind.GetAccessor ? 0 : 1); } @@ -23321,7 +24086,7 @@ namespace ts { function checkGrammarNumericLiteral(node: NumericLiteral): boolean { // Grammar checking - if (node.isOctalLiteral) { + if (node.numericLiteralFlags & NumericLiteralFlags.Octal) { let diagnosticMessage: DiagnosticMessage | undefined; if (languageVersion >= ScriptTarget.ES5) { diagnosticMessage = Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0; diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 41d71c79ac317..a9df1d0d0b81c 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -153,6 +153,12 @@ namespace ts { category: Diagnostics.Basic_Options, description: Diagnostics.Allow_javascript_files_to_be_compiled }, + { + name: "checkJs", + type: "boolean", + category: Diagnostics.Basic_Options, + description: Diagnostics.Report_errors_in_js_files + }, { name: "jsx", type: createMapFromTemplate({ @@ -854,9 +860,9 @@ namespace ts { } /** - * Read tsconfig.json file - * @param fileName The path to the config file - */ + * Read tsconfig.json file + * @param fileName The path to the config file + */ export function readConfigFile(fileName: string, readFile: (path: string) => string): { config?: any; error?: Diagnostic } { let text = ""; try { @@ -869,10 +875,10 @@ namespace ts { } /** - * Parse the text of the tsconfig.json file - * @param fileName The path to the config file - * @param jsonText The text of the config file - */ + * Parse the text of the tsconfig.json file + * @param fileName The path to the config file + * @param jsonText The text of the config file + */ export function parseConfigFileTextToJson(fileName: string, jsonText: string, stripComments = true): { config?: any; error?: Diagnostic } { try { const jsonTextToParse = stripComments ? removeComments(jsonText) : jsonText; @@ -1077,12 +1083,12 @@ namespace ts { } /** - * Parse the contents of a config file (tsconfig.json). - * @param json The contents of the config file to parse - * @param host Instance of ParseConfigHost used to enumerate files in folder. - * @param basePath A root directory to resolve relative path entries in the config - * file to. e.g. outDir - */ + * Parse the contents of a config file (tsconfig.json). + * @param json The contents of the config file to parse + * @param host Instance of ParseConfigHost used to enumerate files in folder. + * @param basePath A root directory to resolve relative path entries in the config + * file to. e.g. outDir + */ export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions: CompilerOptions = {}, configFileName?: string, resolutionStack: Path[] = [], extraFileExtensions: JsFileExtensionInfo[] = []): ParsedCommandLine { const errors: Diagnostic[] = []; basePath = normalizeSlashes(basePath); @@ -1574,7 +1580,7 @@ namespace ts { delete wildcardDirectories[key]; } } - }; + } } return wildcardDirectories; diff --git a/src/compiler/comments.ts b/src/compiler/comments.ts index 9e077ebfaa879..c50cacc2ccb23 100644 --- a/src/compiler/comments.ts +++ b/src/compiler/comments.ts @@ -411,7 +411,7 @@ namespace ts { * Determine if the given comment is a triple-slash * * @return true if the comment is a triple-slash comment else false - **/ + */ function isTripleSlashComment(commentPos: number, commentEnd: number) { // Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text // so that we don't end up computing comment string and doing match for all // comments diff --git a/src/compiler/core.ts b/src/compiler/core.ts index c380a39611dd0..1cca48fd1063f 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -1358,7 +1358,7 @@ namespace ts { /** * Returns length of path root (i.e. length of "/", "x:/", "//server/share/, file:///user/files") - */ + */ export function getRootLength(path: string): number { if (path.charCodeAt(0) === CharacterCodes.slash) { if (path.charCodeAt(1) !== CharacterCodes.slash) return 1; @@ -1455,7 +1455,7 @@ namespace ts { return /^\.\.?($|[\\/])/.test(moduleName); } - export function getEmitScriptTarget(compilerOptions: CompilerOptions | PrinterOptions) { + export function getEmitScriptTarget(compilerOptions: CompilerOptions) { return compilerOptions.target || ScriptTarget.ES3; } @@ -2360,4 +2360,8 @@ namespace ts { return Extension.Jsx; } } + + export function isCheckJsEnabledForFile(sourceFile: SourceFile, compilerOptions: CompilerOptions) { + return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs; + } } diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts index 4a542ab30c7f4..2bd8d5971fb2f 100644 --- a/src/compiler/declarationEmitter.ts +++ b/src/compiler/declarationEmitter.ts @@ -590,7 +590,7 @@ namespace ts { currentIdentifiers = node.identifiers; isCurrentFileExternalModule = isExternalModule(node); enclosingDeclaration = node; - emitDetachedComments(currentText, currentLineMap, writer, writeCommentRange, node, newLine, true /* remove comments */); + emitDetachedComments(currentText, currentLineMap, writer, writeCommentRange, node, newLine, /*removeComents*/ true); emitLines(node.statements); } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 92812604b8a3e..075d4247460e9 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1827,6 +1827,10 @@ "category": "Error", "code": 2549 }, + "Generic type instantiation is excessively deep and possibly infinite.": { + "category": "Error", + "code": 2550 + }, "JSX element attributes type '{0}' may not be a union type.": { "category": "Error", "code": 2600 @@ -3480,6 +3484,24 @@ "category": "Message", "code": 90017 }, + "Disable checking for this file.": { + "category": "Message", + "code": 90018 + }, + "Ignore this error message.": { + "category": "Message", + "code": 90019 + }, + "Initialize property '{0}' in the constructor.": { + "category": "Message", + "code": 90020 + }, + "Initialize static property '{0}'.": { + "category": "Message", + "code": 90021 + }, + + "Octal literal types must use ES2015 syntax. Use the syntax '{0}'.": { "category": "Error", "code": 8017 @@ -3487,5 +3509,9 @@ "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'.": { "category": "Error", "code": 8018 + }, + "Report errors in .js files.": { + "category": "Message", + "code": 8019 } } diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 616be35270ef2..69b5188878f86 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -204,7 +204,6 @@ namespace ts { } = handlers; const newLine = getNewLineCharacter(printerOptions); - const languageVersion = getEmitScriptTarget(printerOptions); const comments = createCommentWriter(printerOptions, onEmitSourceMapOfPosition); const { emitNodeWithComments, @@ -276,6 +275,8 @@ namespace ts { function writeBundle(bundle: Bundle, output: EmitTextWriter) { const previousWriter = writer; setWriter(output); + emitShebangIfNeeded(bundle); + emitPrologueDirectivesIfNeeded(bundle); emitHelpersIndirect(bundle); for (const sourceFile of bundle.sourceFiles) { print(EmitHint.SourceFile, sourceFile, sourceFile); @@ -287,6 +288,8 @@ namespace ts { function writeFile(sourceFile: SourceFile, output: EmitTextWriter) { const previousWriter = writer; setWriter(output); + emitShebangIfNeeded(sourceFile); + emitPrologueDirectivesIfNeeded(sourceFile); print(EmitHint.SourceFile, sourceFile, sourceFile); reset(); writer = previousWriter; @@ -737,15 +740,6 @@ namespace ts { return node && substituteNode && substituteNode(hint, node) || node; } - function emitBodyIndirect(node: Node, elements: NodeArray, emitCallback: (node: Node) => void): void { - if (emitBodyWithDetachedComments) { - emitBodyWithDetachedComments(node, elements, emitCallback); - } - else { - emitCallback(node); - } - } - function emitHelpersIndirect(node: Node) { if (onEmitHelpers) { onEmitHelpers(node, writeLines); @@ -1089,7 +1083,7 @@ namespace ts { } const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None; - const allowTrailingComma = languageVersion >= ScriptTarget.ES5 ? ListFormat.AllowTrailingComma : ListFormat.None; + const allowTrailingComma = currentSourceFile.languageVersion >= ScriptTarget.ES5 ? ListFormat.AllowTrailingComma : ListFormat.None; emitList(node, properties, ListFormat.ObjectLiteralExpressionProperties | allowTrailingComma | preferNewLine); if (indentedFlag) { @@ -1123,11 +1117,11 @@ namespace ts { // 1..toString is a valid property access, emit a dot after the literal // Also emit a dot if expression is a integer const enum value - it will appear in generated code as numeric literal function needsDotDotForPropertyAccess(expression: Expression) { - if (expression.kind === SyntaxKind.NumericLiteral) { + expression = skipPartiallyEmittedExpressions(expression); + if (isNumericLiteral(expression)) { // check if numeric literal is a decimal literal that was originally written with a dot const text = getLiteralTextOfNode(expression); - return getNumericLiteralFlags(text, /*hint*/ NumericLiteralFlags.All) === NumericLiteralFlags.None - && !(expression).isOctalLiteral + return !expression.numericLiteralFlags && text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0; } else if (isPropertyAccessExpression(expression) || isElementAccessExpression(expression)) { @@ -1663,7 +1657,12 @@ namespace ts { ? emitBlockFunctionBodyOnSingleLine : emitBlockFunctionBodyWorker; - emitBodyIndirect(body, body.statements, emitBlockFunctionBody); + if (emitBodyWithDetachedComments) { + emitBodyWithDetachedComments(body, body.statements, emitBlockFunctionBody); + } + else { + emitBlockFunctionBody(body); + } decreaseIndent(); writeToken(SyntaxKind.CloseBraceToken, body.statements.end, body); @@ -2072,16 +2071,27 @@ namespace ts { function emitSourceFile(node: SourceFile) { writeLine(); - emitShebang(); - emitBodyIndirect(node, node.statements, emitSourceFileWorker); + const statements = node.statements; + if (emitBodyWithDetachedComments) { + // Emit detached comment if there are no prologue directives or if the first node is synthesized. + // The synthesized node will have no leading comment so some comments may be missed. + const shouldEmitDetachedComment = statements.length === 0 || + !isPrologueDirective(statements[0]) || + nodeIsSynthesized(statements[0]); + if (shouldEmitDetachedComment) { + emitBodyWithDetachedComments(node, statements, emitSourceFileWorker); + return; + } + } + emitSourceFileWorker(node); } function emitSourceFileWorker(node: SourceFile) { const statements = node.statements; - const statementOffset = emitPrologueDirectives(statements); pushNameGenerationScope(); emitHelpersIndirect(node); - emitList(node, statements, ListFormat.MultiLine, statementOffset); + const index = findIndex(statements, statement => !isPrologueDirective(statement)); + emitList(node, statements, ListFormat.MultiLine, index === -1 ? statements.length : index); popNameGenerationScope(); } @@ -2095,13 +2105,20 @@ namespace ts { * Emits any prologue directives at the start of a Statement list, returning the * number of prologue directives written to the output. */ - function emitPrologueDirectives(statements: Node[], startWithNewLine?: boolean): number { + function emitPrologueDirectives(statements: Node[], startWithNewLine?: boolean, seenPrologueDirectives?: Map): number { for (let i = 0; i < statements.length; i++) { - if (isPrologueDirective(statements[i])) { - if (startWithNewLine || i > 0) { - writeLine(); + const statement = statements[i]; + if (isPrologueDirective(statement)) { + const shouldEmitPrologueDirective = seenPrologueDirectives ? !seenPrologueDirectives.has(statement.expression.text) : true; + if (shouldEmitPrologueDirective) { + if (startWithNewLine || i > 0) { + writeLine(); + } + emit(statement); + if (seenPrologueDirectives) { + seenPrologueDirectives.set(statement.expression.text, statement.expression.text); + } } - emit(statements[i]); } else { // return index of the first non prologue directive @@ -2112,18 +2129,43 @@ namespace ts { return statements.length; } - // - // Helpers - // + function emitPrologueDirectivesIfNeeded(sourceFileOrBundle: Bundle | SourceFile) { + if (isSourceFile(sourceFileOrBundle)) { + setSourceFile(sourceFileOrBundle as SourceFile); + emitPrologueDirectives((sourceFileOrBundle as SourceFile).statements); + } + else { + const seenPrologueDirectives = createMap(); + for (const sourceFile of (sourceFileOrBundle as Bundle).sourceFiles) { + setSourceFile(sourceFile); + emitPrologueDirectives(sourceFile.statements, /*startWithNewLine*/ true, seenPrologueDirectives); + } + } + } - function emitShebang() { - const shebang = getShebang(currentSourceFile.text); - if (shebang) { - write(shebang); - writeLine(); + function emitShebangIfNeeded(sourceFileOrBundle: Bundle | SourceFile) { + if (isSourceFile(sourceFileOrBundle)) { + const shebang = getShebang(sourceFileOrBundle.text); + if (shebang) { + write(shebang); + writeLine(); + return true; + } + } + else { + for (const sourceFile of sourceFileOrBundle.sourceFiles) { + // Emit only the first encountered shebang + if (emitShebangIfNeeded(sourceFile)) { + break; + } + } } } + // + // Helpers + // + function emitModifiers(node: Node, modifiers: NodeArray) { if (modifiers && modifiers.length) { emitList(node, modifiers, ListFormat.Modifiers); @@ -2595,7 +2637,7 @@ namespace ts { } } - return getLiteralText(node, currentSourceFile, languageVersion); + return getLiteralText(node, currentSourceFile); } /** diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts index 453cd04114840..cf307199da087 100644 --- a/src/compiler/factory.ts +++ b/src/compiler/factory.ts @@ -45,7 +45,7 @@ namespace ts { * Creates a shallow, memberwise clone of a node with no source map location. */ /* @internal */ - export function getSynthesizedClone(node: T): T { + export function getSynthesizedClone(node: T | undefined): T { // We don't use "clone" from core.ts here, as we need to preserve the prototype chain of // the original node. We also need to exclude specific properties and only include own- // properties (to skip members already defined on the shared prototype). @@ -88,6 +88,7 @@ namespace ts { export function createNumericLiteral(value: string): NumericLiteral { const node = createSynthesizedNode(SyntaxKind.NumericLiteral); node.text = value; + node.numericLiteralFlags = 0; return node; } @@ -166,23 +167,23 @@ namespace ts { // Reserved words export function createSuper() { - return createSynthesizedNode(SyntaxKind.SuperKeyword); + return createSynthesizedNode(SyntaxKind.SuperKeyword); } export function createThis() { - return createSynthesizedNode(SyntaxKind.ThisKeyword); + return >createSynthesizedNode(SyntaxKind.ThisKeyword); } export function createNull() { - return createSynthesizedNode(SyntaxKind.NullKeyword); + return >createSynthesizedNode(SyntaxKind.NullKeyword); } export function createTrue() { - return createSynthesizedNode(SyntaxKind.TrueKeyword); + return >createSynthesizedNode(SyntaxKind.TrueKeyword); } export function createFalse() { - return createSynthesizedNode(SyntaxKind.FalseKeyword); + return >createSynthesizedNode(SyntaxKind.FalseKeyword); } // Names @@ -213,6 +214,284 @@ namespace ts { : node; } + // Type Elements + + export function createSignatureDeclaration(kind: SyntaxKind, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) { + const signatureDeclaration = createSynthesizedNode(kind) as SignatureDeclaration; + signatureDeclaration.typeParameters = asNodeArray(typeParameters); + signatureDeclaration.parameters = asNodeArray(parameters); + signatureDeclaration.type = type; + return signatureDeclaration; + } + + function updateSignatureDeclaration(node: SignatureDeclaration, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined) { + return node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + ? updateNode(createSignatureDeclaration(node.kind, typeParameters, parameters, type), node) + : node; + } + + export function createFunctionTypeNode(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) { + return createSignatureDeclaration(SyntaxKind.FunctionType, typeParameters, parameters, type) as FunctionTypeNode; + } + + export function updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined) { + return updateSignatureDeclaration(node, typeParameters, parameters, type); + } + + export function createConstructorTypeNode(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) { + return createSignatureDeclaration(SyntaxKind.ConstructorType, typeParameters, parameters, type) as ConstructorTypeNode; + } + + export function updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined) { + return updateSignatureDeclaration(node, typeParameters, parameters, type); + } + + export function createCallSignatureDeclaration(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) { + return createSignatureDeclaration(SyntaxKind.CallSignature, typeParameters, parameters, type) as CallSignatureDeclaration; + } + + export function updateCallSignatureDeclaration(node: CallSignatureDeclaration, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined) { + return updateSignatureDeclaration(node, typeParameters, parameters, type); + } + + export function createConstructSignatureDeclaration(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) { + return createSignatureDeclaration(SyntaxKind.ConstructSignature, typeParameters, parameters, type) as ConstructSignatureDeclaration; + } + + export function updateConstructSignatureDeclaration(node: ConstructSignatureDeclaration, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined) { + return updateSignatureDeclaration(node, typeParameters, parameters, type); + } + + export function createMethodSignature(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined) { + const methodSignature = createSignatureDeclaration(SyntaxKind.MethodSignature, typeParameters, parameters, type) as MethodSignature; + methodSignature.name = asName(name); + methodSignature.questionToken = questionToken; + return methodSignature; + } + + export function updateMethodSignature(node: MethodSignature, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined, name: PropertyName, questionToken: QuestionToken | undefined) { + return node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.name !== name + || node.questionToken !== questionToken + ? updateNode(createMethodSignature(typeParameters, parameters, type, name, questionToken), node) + : node; + } + + // Types + + export function createKeywordTypeNode(kind: KeywordTypeNode["kind"]) { + return createSynthesizedNode(kind); + } + + export function createThisTypeNode() { + return createSynthesizedNode(SyntaxKind.ThisType); + } + + export function createLiteralTypeNode(literal: Expression) { + const literalTypeNode = createSynthesizedNode(SyntaxKind.LiteralType) as LiteralTypeNode; + literalTypeNode.literal = literal; + return literalTypeNode; + } + + export function updateLiteralTypeNode(node: LiteralTypeNode, literal: Expression) { + return node.literal !== literal + ? updateNode(createLiteralTypeNode(literal), node) + : node; + } + + export function createTypeReferenceNode(typeName: string | EntityName, typeArguments: TypeNode[] | undefined) { + const typeReference = createSynthesizedNode(SyntaxKind.TypeReference) as TypeReferenceNode; + typeReference.typeName = asName(typeName); + typeReference.typeArguments = asNodeArray(typeArguments); + return typeReference; + } + + export function updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray | undefined) { + return node.typeName !== typeName + || node.typeArguments !== typeArguments + ? updateNode(createTypeReferenceNode(typeName, typeArguments), node) + : node; + } + + export function createTypePredicateNode(parameterName: Identifier | ThisTypeNode | string, type: TypeNode) { + const typePredicateNode = createSynthesizedNode(SyntaxKind.TypePredicate) as TypePredicateNode; + typePredicateNode.parameterName = asName(parameterName); + typePredicateNode.type = type; + return typePredicateNode; + } + + export function updateTypePredicateNode(node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode) { + return node.parameterName !== parameterName + || node.type !== type + ? updateNode(createTypePredicateNode(parameterName, type), node) + : node; + } + + export function createTypeQueryNode(exprName: EntityName) { + const typeQueryNode = createSynthesizedNode(SyntaxKind.TypeQuery) as TypeQueryNode; + typeQueryNode.exprName = exprName; + return typeQueryNode; + } + + export function updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName) { + return node.exprName !== exprName ? updateNode(createTypeQueryNode(exprName), node) : node; + } + + export function createArrayTypeNode(elementType: TypeNode) { + const arrayTypeNode = createSynthesizedNode(SyntaxKind.ArrayType) as ArrayTypeNode; + arrayTypeNode.elementType = elementType; + return arrayTypeNode; + } + + export function updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode { + return node.elementType !== elementType + ? updateNode(createArrayTypeNode(elementType), node) + : node; + } + + export function createUnionOrIntersectionTypeNode(kind: SyntaxKind.UnionType, types: TypeNode[]): UnionTypeNode; + export function createUnionOrIntersectionTypeNode(kind: SyntaxKind.IntersectionType, types: TypeNode[]): IntersectionTypeNode; + export function createUnionOrIntersectionTypeNode(kind: SyntaxKind.UnionType | SyntaxKind.IntersectionType, types: TypeNode[]): UnionOrIntersectionTypeNode; + export function createUnionOrIntersectionTypeNode(kind: SyntaxKind.UnionType | SyntaxKind.IntersectionType, types: TypeNode[]) { + const unionTypeNode = createSynthesizedNode(kind) as UnionTypeNode | IntersectionTypeNode; + unionTypeNode.types = createNodeArray(types); + return unionTypeNode; + } + + export function updateUnionOrIntersectionTypeNode(node: UnionOrIntersectionTypeNode, types: NodeArray) { + return node.types !== types + ? updateNode(createUnionOrIntersectionTypeNode(node.kind, types), node) + : node; + } + + export function createTypeLiteralNode(members: TypeElement[]) { + const typeLiteralNode = createSynthesizedNode(SyntaxKind.TypeLiteral) as TypeLiteralNode; + typeLiteralNode.members = createNodeArray(members); + return typeLiteralNode; + } + + export function updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray) { + return node.members !== members + ? updateNode(createTypeLiteralNode(members), node) + : node; + } + + export function createTupleTypeNode(elementTypes: TypeNode[]) { + const tupleTypeNode = createSynthesizedNode(SyntaxKind.TupleType) as TupleTypeNode; + tupleTypeNode.elementTypes = createNodeArray(elementTypes); + return tupleTypeNode; + } + + export function updateTypleTypeNode(node: TupleTypeNode, elementTypes: TypeNode[]) { + return node.elementTypes !== elementTypes + ? updateNode(createTupleTypeNode(elementTypes), node) + : node; + } + + export function createMappedTypeNode(readonlyToken: ReadonlyToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | undefined, type: TypeNode | undefined): MappedTypeNode { + const mappedTypeNode = createSynthesizedNode(SyntaxKind.MappedType) as MappedTypeNode; + mappedTypeNode.readonlyToken = readonlyToken; + mappedTypeNode.typeParameter = typeParameter; + mappedTypeNode.questionToken = questionToken; + mappedTypeNode.type = type; + return mappedTypeNode; + } + + export function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | undefined, type: TypeNode | undefined): MappedTypeNode { + return node.readonlyToken !== readonlyToken + || node.typeParameter !== typeParameter + || node.questionToken !== questionToken + || node.type !== type + ? updateNode(createMappedTypeNode(readonlyToken, typeParameter, questionToken, type), node) + : node; + } + + export function createTypeOperatorNode(type: TypeNode) { + const typeOperatorNode = createSynthesizedNode(SyntaxKind.TypeOperator) as TypeOperatorNode; + typeOperatorNode.operator = SyntaxKind.KeyOfKeyword; + typeOperatorNode.type = type; + return typeOperatorNode; + } + + export function updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode) { + return node.type !== type ? updateNode(createTypeOperatorNode(type), node) : node; + } + + export function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode) { + const indexedAccessTypeNode = createSynthesizedNode(SyntaxKind.IndexedAccessType) as IndexedAccessTypeNode; + indexedAccessTypeNode.objectType = objectType; + indexedAccessTypeNode.indexType = indexType; + return indexedAccessTypeNode; + } + + export function updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode) { + return node.objectType !== objectType + || node.indexType !== indexType + ? updateNode(createIndexedAccessTypeNode(objectType, indexType), node) + : node; + } + + // Type Declarations + + export function createTypeParameterDeclaration(name: string | Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined) { + const typeParameter = createSynthesizedNode(SyntaxKind.TypeParameter) as TypeParameterDeclaration; + typeParameter.name = asName(name); + typeParameter.constraint = constraint; + typeParameter.default = defaultType; + + return typeParameter; + } + + export function updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined) { + return node.name !== name + || node.constraint !== constraint + || node.default !== defaultType + ? updateNode(createTypeParameterDeclaration(name, constraint, defaultType), node) + : node; + } + + // Signature elements + + export function createPropertySignature(name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertySignature { + const propertySignature = createSynthesizedNode(SyntaxKind.PropertySignature) as PropertySignature; + propertySignature.name = asName(name); + propertySignature.questionToken = questionToken; + propertySignature.type = type; + propertySignature.initializer = initializer; + return propertySignature; + } + + export function updatePropertySignature(node: PropertySignature, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) { + return node.name !== name + || node.questionToken !== questionToken + || node.type !== type + || node.initializer !== initializer + ? updateNode(createPropertySignature(name, questionToken, type, initializer), node) + : node; + } + + export function createIndexSignatureDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, parameters: ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration { + const indexSignature = createSynthesizedNode(SyntaxKind.IndexSignature) as IndexSignatureDeclaration; + indexSignature.decorators = asNodeArray(decorators); + indexSignature.modifiers = asNodeArray(modifiers); + indexSignature.parameters = createNodeArray(parameters); + indexSignature.type = type; + return indexSignature; + } + + export function updateIndexSignatureDeclaration(node: IndexSignatureDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, parameters: ParameterDeclaration[], type: TypeNode) { + return node.parameters !== parameters + || node.type !== type + || node.decorators !== decorators + || node.modifiers !== modifiers + ? updateNode(createIndexSignatureDeclaration(decorators, modifiers, parameters, type), node) + : node; + } + // Signature elements export function createParameter(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression) { @@ -227,11 +506,12 @@ namespace ts { return node; } - export function updateParameter(node: ParameterDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: BindingName, type: TypeNode | undefined, initializer: Expression | undefined) { + export function updateParameter(node: ParameterDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) { return node.decorators !== decorators || node.modifiers !== modifiers || node.dotDotDotToken !== dotDotDotToken || node.name !== name + || node.questionToken !== questionToken || node.type !== type || node.initializer !== initializer ? updateNode(createParameter(decorators, modifiers, dotDotDotToken, name, node.questionToken, type, initializer), node) @@ -273,12 +553,13 @@ namespace ts { : node; } - export function createMethod(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) { + export function createMethodDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) { const node = createSynthesizedNode(SyntaxKind.MethodDeclaration); node.decorators = asNodeArray(decorators); node.modifiers = asNodeArray(modifiers); node.asteriskToken = asteriskToken; node.name = asName(name); + node.questionToken = questionToken; node.typeParameters = asNodeArray(typeParameters); node.parameters = createNodeArray(parameters); node.type = type; @@ -286,7 +567,7 @@ namespace ts { return node; } - export function updateMethod(node: MethodDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) { + export function updateMethod(node: MethodDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) { return node.decorators !== decorators || node.modifiers !== modifiers || node.asteriskToken !== asteriskToken @@ -295,7 +576,7 @@ namespace ts { || node.parameters !== parameters || node.type !== type || node.body !== body - ? updateNode(createMethod(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) + ? updateNode(createMethodDeclaration(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body), node) : node; } @@ -1099,10 +1380,6 @@ namespace ts { : node; } - export function createKeywordTypeNode(kind: KeywordTypeNode["kind"]): KeywordTypeNode { - return createSynthesizedNode(kind); - } - export function createFunctionDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) { const node = createSynthesizedNode(SyntaxKind.FunctionDeclaration); node.decorators = asNodeArray(decorators); @@ -1793,7 +2070,9 @@ namespace ts { function asName(name: string | Identifier): Identifier; function asName(name: string | BindingName): BindingName; function asName(name: string | PropertyName): PropertyName; - function asName(name: string | Identifier | BindingName | PropertyName) { + function asName(name: string | EntityName): EntityName; + function asName(name: string | Identifier | ThisTypeNode): Identifier | ThisTypeNode; + function asName(name: string | Identifier | BindingName | PropertyName | QualifiedName | ThisTypeNode) { return typeof name === "string" ? createIdentifier(name) : name; } @@ -3087,17 +3366,14 @@ namespace ts { */ export function parenthesizeForAccess(expression: Expression): LeftHandSideExpression { // isLeftHandSideExpression is almost the correct criterion for when it is not necessary - // to parenthesize the expression before a dot. The known exceptions are: + // to parenthesize the expression before a dot. The known exception is: // // NewExpression: // new C.x -> not the same as (new C).x - // NumericLiteral - // 1.x -> not the same as (1).x // const emittedExpression = skipPartiallyEmittedExpressions(expression); if (isLeftHandSideExpression(emittedExpression) - && (emittedExpression.kind !== SyntaxKind.NewExpression || (emittedExpression).arguments) - && emittedExpression.kind !== SyntaxKind.NumericLiteral) { + && (emittedExpression.kind !== SyntaxKind.NewExpression || (emittedExpression).arguments)) { return expression; } @@ -3213,8 +3489,7 @@ namespace ts { } export function parenthesizeConciseBody(body: ConciseBody): ConciseBody { - const emittedBody = skipPartiallyEmittedExpressions(body); - if (emittedBody.kind === SyntaxKind.ObjectLiteralExpression) { + if (!isBlock(body) && getLeftmostExpression(body).kind === SyntaxKind.ObjectLiteralExpression) { return setTextRange(createParen(body), body); } diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts index 699919e0566c7..5280c79472575 100644 --- a/src/compiler/moduleNameResolver.ts +++ b/src/compiler/moduleNameResolver.ts @@ -249,13 +249,13 @@ namespace ts { } /** - * Given a set of options, returns the set of type directive names - * that should be included for this program automatically. - * This list could either come from the config file, - * or from enumerating the types root + initial secondary types lookup location. - * More type directives might appear in the program later as a result of loading actual source files; - * this list is only the set of defaults that are implicitly included. - */ + * Given a set of options, returns the set of type directive names + * that should be included for this program automatically. + * This list could either come from the config file, + * or from enumerating the types root + initial secondary types lookup location. + * More type directives might appear in the program later as a result of loading actual source files; + * this list is only the set of defaults that are implicitly included. + */ export function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[] { // Use explicit type list from tsconfig.json if (options.types) { diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index ee74ce9c9a596..a82d5b02b4402 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1267,6 +1267,7 @@ namespace ts { function nextTokenIsClassOrFunctionOrAsync(): boolean { nextToken(); return token() === SyntaxKind.ClassKeyword || token() === SyntaxKind.FunctionKeyword || + (token() === SyntaxKind.AbstractKeyword && lookAhead(nextTokenIsClassKeywordOnSameLine)) || (token() === SyntaxKind.AsyncKeyword && lookAhead(nextTokenIsFunctionKeywordOnSameLine)); } @@ -1844,7 +1845,7 @@ namespace ts { case ParsingContext.JSDocTupleTypes: return Diagnostics.Type_expected; case ParsingContext.JSDocRecordMembers: return Diagnostics.Property_assignment_expected; } - }; + } // Parses a comma-delimited list of elements function parseDelimitedList(kind: ParsingContext, parseElement: () => T, considerSemicolonAsDelimiter?: boolean): NodeArray { @@ -2030,32 +2031,27 @@ namespace ts { node.isUnterminated = true; } - const tokenPos = scanner.getTokenPos(); - nextToken(); - finishNode(node); - // Octal literals are not allowed in strict mode or ES5 // Note that theoretically the following condition would hold true literals like 009, // which is not octal.But because of how the scanner separates the tokens, we would // never get a token like this. Instead, we would get 00 and 9 as two separate tokens. // We also do not need to check for negatives because any prefix operator would be part of a // parent unary expression. - if (node.kind === SyntaxKind.NumericLiteral - && sourceText.charCodeAt(tokenPos) === CharacterCodes._0 - && isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) { - - node.isOctalLiteral = true; + if (node.kind === SyntaxKind.NumericLiteral) { + (node).numericLiteralFlags = scanner.getNumericLiteralFlags(); } + nextToken(); + finishNode(node); + return node; } // TYPES function parseTypeReference(): TypeReferenceNode { - const typeName = parseEntityName(/*allowReservedWords*/ false, Diagnostics.Type_expected); - const node = createNode(SyntaxKind.TypeReference, typeName.pos); - node.typeName = typeName; + const node = createNode(SyntaxKind.TypeReference); + node.typeName = parseEntityName(/*allowReservedWords*/ false, Diagnostics.Type_expected); if (!scanner.hasPrecedingLineBreak() && token() === SyntaxKind.LessThanToken) { node.typeArguments = parseBracketedList(ParsingContext.TypeArguments, parseType, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken); } @@ -4661,6 +4657,11 @@ namespace ts { return tokenIsIdentifierOrKeyword(token()) && !scanner.hasPrecedingLineBreak(); } + function nextTokenIsClassKeywordOnSameLine() { + nextToken(); + return token() === SyntaxKind.ClassKeyword && !scanner.hasPrecedingLineBreak(); + } + function nextTokenIsFunctionKeywordOnSameLine() { nextToken(); return token() === SyntaxKind.FunctionKeyword && !scanner.hasPrecedingLineBreak(); @@ -5822,6 +5823,7 @@ namespace ts { const typeReferenceDirectives: FileReference[] = []; const amdDependencies: { path: string; name: string }[] = []; let amdModuleName: string; + let checkJsDirective: CheckJsDirective = undefined; // Keep scanning all the leading trivia in the file until we get to something that // isn't trivia. Any single line comment will be analyzed to see if it is a @@ -5883,6 +5885,16 @@ namespace ts { amdDependencies.push(amdDependency); } } + + const checkJsDirectiveRegEx = /^\/\/\/?\s*(@ts-check|@ts-nocheck)\s*$/gim; + const checkJsDirectiveMatchResult = checkJsDirectiveRegEx.exec(comment); + if (checkJsDirectiveMatchResult) { + checkJsDirective = { + enabled: compareStrings(checkJsDirectiveMatchResult[1], "@ts-check", /*ignoreCase*/ true) === Comparison.EqualTo, + end: range.end, + pos: range.pos + }; + } } } @@ -5890,6 +5902,7 @@ namespace ts { sourceFile.typeReferenceDirectives = typeReferenceDirectives; sourceFile.amdDependencies = amdDependencies; sourceFile.moduleName = amdModuleName; + sourceFile.checkJsDirective = checkJsDirective; } function setExternalModuleIndicator(sourceFile: SourceFile) { @@ -6516,7 +6529,7 @@ namespace ts { function parseTagComments(indent: number) { const comments: string[] = []; - let state = JSDocState.SawAsterisk; + let state = JSDocState.BeginningOfLine; let margin: number | undefined; function pushComment(text: string) { if (!margin) { diff --git a/src/compiler/program.ts b/src/compiler/program.ts index cffb6df1e3d7d..31fc665649a73 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -4,6 +4,7 @@ namespace ts { const emptyArray: any[] = []; + const ignoreDiagnosticCommentRegEx = /(^\s*$)|(^\s*\/\/\/?\s*(@ts-ignore)?)/; export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName = "tsconfig.json"): string { while (true) { @@ -911,17 +912,42 @@ namespace ts { Debug.assert(!!sourceFile.bindDiagnostics); const bindDiagnostics = sourceFile.bindDiagnostics; - // For JavaScript files, we don't want to report semantic errors. - // Instead, we'll report errors for using TypeScript-only constructs from within a - // JavaScript file when we get syntactic diagnostics for the file. - const checkDiagnostics = isSourceFileJavaScript(sourceFile) ? [] : typeChecker.getDiagnostics(sourceFile, cancellationToken); + // For JavaScript files, we don't want to report semantic errors unless explicitly requested. + const includeCheckDiagnostics = !isSourceFileJavaScript(sourceFile) || isCheckJsEnabledForFile(sourceFile, options); + const checkDiagnostics = includeCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : []; const fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName); const programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName); - return bindDiagnostics.concat(checkDiagnostics, fileProcessingDiagnosticsInFile, programDiagnosticsInFile); + const diagnostics = bindDiagnostics.concat(checkDiagnostics, fileProcessingDiagnosticsInFile, programDiagnosticsInFile); + return isSourceFileJavaScript(sourceFile) + ? filter(diagnostics, shouldReportDiagnostic) + : diagnostics; }); } + /** + * Skip errors if previous line start with '// @ts-ignore' comment, not counting non-empty non-comment lines + */ + function shouldReportDiagnostic(diagnostic: Diagnostic) { + const { file, start } = diagnostic; + const lineStarts = getLineStarts(file); + let { line } = computeLineAndCharacterOfPosition(lineStarts, start); + while (line > 0) { + const previousLineText = file.text.slice(lineStarts[line - 1], lineStarts[line]); + const result = ignoreDiagnosticCommentRegEx.exec(previousLineText); + if (!result) { + // non-empty line + return true; + } + if (result[3]) { + // @ts-ignore + return false; + } + line--; + } + return true; + } + function getJavaScriptSyntacticDiagnosticsForFile(sourceFile: SourceFile): Diagnostic[] { return runWithCancellationToken(() => { const diagnostics: Diagnostic[] = []; @@ -1722,6 +1748,10 @@ namespace ts { programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "allowJs", "declaration")); } + if (options.checkJs && !options.allowJs) { + programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "checkJs", "allowJs")); + } + if (options.emitDecoratorMetadata && !options.experimentalDecorators) { programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators")); diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 466074bdbcc6f..7b6e0c09db48b 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -23,6 +23,8 @@ namespace ts { isIdentifier(): boolean; isReservedWord(): boolean; isUnterminated(): boolean; + /* @internal */ + getNumericLiteralFlags(): NumericLiteralFlags; reScanGreaterToken(): SyntaxKind; reScanSlashToken(): SyntaxKind; reScanTemplateToken(): SyntaxKind; @@ -799,6 +801,7 @@ namespace ts { let precedingLineBreak: boolean; let hasExtendedUnicodeEscape: boolean; let tokenIsUnterminated: boolean; + let numericLiteralFlags: NumericLiteralFlags; setText(text, start, length); @@ -814,6 +817,7 @@ namespace ts { isIdentifier: () => token === SyntaxKind.Identifier || token > SyntaxKind.LastReservedWord, isReservedWord: () => token >= SyntaxKind.FirstReservedWord && token <= SyntaxKind.LastReservedWord, isUnterminated: () => tokenIsUnterminated, + getNumericLiteralFlags: () => numericLiteralFlags, reScanGreaterToken, reScanSlashToken, reScanTemplateToken, @@ -850,6 +854,7 @@ namespace ts { let end = pos; if (text.charCodeAt(pos) === CharacterCodes.E || text.charCodeAt(pos) === CharacterCodes.e) { pos++; + numericLiteralFlags = NumericLiteralFlags.Scientific; if (text.charCodeAt(pos) === CharacterCodes.plus || text.charCodeAt(pos) === CharacterCodes.minus) pos++; if (isDigit(text.charCodeAt(pos))) { pos++; @@ -1221,6 +1226,7 @@ namespace ts { hasExtendedUnicodeEscape = false; precedingLineBreak = false; tokenIsUnterminated = false; + numericLiteralFlags = 0; while (true) { tokenPos = pos; if (pos >= end) { @@ -1419,6 +1425,7 @@ namespace ts { value = 0; } tokenValue = "" + value; + numericLiteralFlags = NumericLiteralFlags.HexSpecifier; return token = SyntaxKind.NumericLiteral; } else if (pos + 2 < end && (text.charCodeAt(pos + 1) === CharacterCodes.B || text.charCodeAt(pos + 1) === CharacterCodes.b)) { @@ -1429,6 +1436,7 @@ namespace ts { value = 0; } tokenValue = "" + value; + numericLiteralFlags = NumericLiteralFlags.BinarySpecifier; return token = SyntaxKind.NumericLiteral; } else if (pos + 2 < end && (text.charCodeAt(pos + 1) === CharacterCodes.O || text.charCodeAt(pos + 1) === CharacterCodes.o)) { @@ -1439,11 +1447,13 @@ namespace ts { value = 0; } tokenValue = "" + value; + numericLiteralFlags = NumericLiteralFlags.OctalSpecifier; return token = SyntaxKind.NumericLiteral; } // Try to parse as an octal if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) { tokenValue = "" + scanOctalDigits(); + numericLiteralFlags = NumericLiteralFlags.Octal; return token = SyntaxKind.NumericLiteral; } // This fall-through is a deviation from the EcmaScript grammar. The grammar says that a leading zero diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts index 5275d21017241..b65370076d279 100644 --- a/src/compiler/sys.ts +++ b/src/compiler/sys.ts @@ -54,10 +54,10 @@ namespace ts { referenceCount: number; } - declare var require: any; - declare var process: any; - declare var global: any; - declare var __filename: string; + declare const require: any; + declare const process: any; + declare const global: any; + declare const __filename: string; export function getNodeMajorVersion() { if (typeof process === "undefined") { @@ -74,7 +74,7 @@ namespace ts { return parseInt(version.substring(1, dot)); } - declare var ChakraHost: { + declare const ChakraHost: { args: string[]; currentDirectory: string; executingFile: string; @@ -368,7 +368,7 @@ namespace ts { if (eventName === "rename") { // When deleting a file, the passed baseFileName is null callback(!relativeFileName ? relativeFileName : normalizePath(combinePaths(directoryName, relativeFileName))); - }; + } } ); }, diff --git a/src/compiler/transformers/destructuring.ts b/src/compiler/transformers/destructuring.ts index df372fd9a2c7f..bbc79270c776a 100644 --- a/src/compiler/transformers/destructuring.ts +++ b/src/compiler/transformers/destructuring.ts @@ -490,7 +490,8 @@ namespace ts { }; /** Given value: o, propName: p, pattern: { a, b, ...p } from the original statement - * `{ a, b, ...p } = o`, create `p = __rest(o, ["a", "b"]);`*/ + * `{ a, b, ...p } = o`, create `p = __rest(o, ["a", "b"]);` + */ function createRestCall(context: TransformationContext, value: Expression, elements: BindingOrAssignmentElement[], computedTempVariables: Expression[], location: TextRange): Expression { context.requestEmitHelper(restHelper); const propertyNames: Expression[] = []; diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts index fd2c287d0e054..a3e34693259a5 100644 --- a/src/compiler/transformers/es2015.ts +++ b/src/compiler/transformers/es2015.ts @@ -315,7 +315,7 @@ namespace ts { * Sets the `HierarchyFacts` for this node prior to visiting this node's subtree, returning the facts set prior to modification. * @param excludeFacts The existing `HierarchyFacts` to reset before visiting the subtree. * @param includeFacts The new `HierarchyFacts` to set before visiting the subtree. - **/ + */ function enterSubtree(excludeFacts: HierarchyFacts, includeFacts: HierarchyFacts) { const ancestorFacts = hierarchyFacts; hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & HierarchyFacts.AncestorFactsMask; @@ -328,7 +328,7 @@ namespace ts { * @param ancestorFacts The `HierarchyFacts` of the ancestor to restore after visiting the subtree. * @param excludeFacts The existing `HierarchyFacts` of the subtree that should not be propagated. * @param includeFacts The new `HierarchyFacts` of the subtree that should be propagated. - **/ + */ function exitSubtree(ancestorFacts: HierarchyFacts, excludeFacts: HierarchyFacts, includeFacts: HierarchyFacts) { hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & HierarchyFacts.SubtreeFactsMask | ancestorFacts; } @@ -466,6 +466,12 @@ namespace ts { case SyntaxKind.TemplateTail: return visitTemplateLiteral(node); + case SyntaxKind.StringLiteral: + return visitStringLiteral(node); + + case SyntaxKind.NumericLiteral: + return visitNumericLiteral(node); + case SyntaxKind.TaggedTemplateExpression: return visitTaggedTemplateExpression(node); @@ -3414,6 +3420,30 @@ namespace ts { return setTextRange(createLiteral(node.text), node); } + /** + * Visits a string literal with an extended unicode escape. + * + * @param node A string literal. + */ + function visitStringLiteral(node: StringLiteral) { + if (node.hasExtendedUnicodeEscape) { + return setTextRange(createLiteral(node.text), node); + } + return node; + } + + /** + * Visits a binary or octal (ES6) numeric literal. + * + * @param node A string literal. + */ + function visitNumericLiteral(node: NumericLiteral) { + if (node.numericLiteralFlags & NumericLiteralFlags.BinaryOrOctalSpecifier) { + return setTextRange(createNumericLiteral(node.text), node); + } + return node; + } + /** * Visits a TaggedTemplateExpression node. * diff --git a/src/compiler/transformers/es2017.ts b/src/compiler/transformers/es2017.ts index 31aae5055a002..088c57866d08f 100644 --- a/src/compiler/transformers/es2017.ts +++ b/src/compiler/transformers/es2017.ts @@ -125,6 +125,7 @@ namespace ts { visitNodes(node.modifiers, visitor, isModifier), node.asteriskToken, node.name, + /*questionToken*/ undefined, /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), /*type*/ undefined, diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index 971dddd20eaee..83e84e6eab58f 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -475,6 +475,7 @@ namespace ts { /*modifiers*/ undefined, node.dotDotDotToken, getGeneratedNameForNode(node), + /*questionToken*/ undefined, /*type*/ undefined, visitNode(node.initializer, visitor, isExpression) ); @@ -540,6 +541,7 @@ namespace ts { ? undefined : node.asteriskToken, visitNode(node.name, visitor, isPropertyName), + visitNode(/*questionToken*/ undefined, visitor, isToken), /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), /*type*/ undefined, diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts index e55cfc76db339..d2f2162f45505 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -1478,7 +1478,7 @@ namespace ts { } const initializer = node.initializer; - if (isVariableDeclarationList(initializer)) { + if (initializer && isVariableDeclarationList(initializer)) { for (const variable of initializer.declarations) { hoistVariableDeclaration(variable.name); } diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts index 4ef9c674ad952..4fe7b027e93a4 100644 --- a/src/compiler/transformers/module/module.ts +++ b/src/compiler/transformers/module/module.ts @@ -359,15 +359,20 @@ namespace ts { // Find the name of the module alias, if there is one const importAliasName = getLocalNameForExternalImport(importNode, currentSourceFile); - if (includeNonAmdDependencies && importAliasName) { - // Set emitFlags on the name of the classDeclaration - // This is so that when printer will not substitute the identifier - setEmitFlags(importAliasName, EmitFlags.NoSubstitution); - aliasedModuleNames.push(externalModuleName); - importAliasNames.push(createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, importAliasName)); - } - else { - unaliasedModuleNames.push(externalModuleName); + // It is possible that externalModuleName is undefined if it is not string literal. + // This can happen in the invalid import syntax. + // E.g : "import * from alias from 'someLib';" + if (externalModuleName) { + if (includeNonAmdDependencies && importAliasName) { + // Set emitFlags on the name of the classDeclaration + // This is so that when printer will not substitute the identifier + setEmitFlags(importAliasName, EmitFlags.NoSubstitution); + aliasedModuleNames.push(externalModuleName); + importAliasNames.push(createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, importAliasName)); + } + else { + unaliasedModuleNames.push(externalModuleName); + } } } @@ -1157,7 +1162,7 @@ namespace ts { statement = createStatement( createExportExpression( createIdentifier("__esModule"), - createLiteral(true) + createLiteral(/*value*/ true) ) ); } @@ -1170,7 +1175,7 @@ namespace ts { createIdentifier("exports"), createLiteral("__esModule"), createObjectLiteral([ - createPropertyAssignment("value", createLiteral(true)) + createPropertyAssignment("value", createLiteral(/*value*/ true)) ]) ] ) diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts index 642ac1ce6fbaf..56341f482ffc5 100644 --- a/src/compiler/transformers/module/system.ts +++ b/src/compiler/transformers/module/system.ts @@ -151,18 +151,20 @@ namespace ts { for (let i = 0; i < externalImports.length; i++) { const externalImport = externalImports[i]; const externalModuleName = getExternalModuleNameLiteral(externalImport, currentSourceFile, host, resolver, compilerOptions); - const text = externalModuleName.text; - const groupIndex = groupIndices.get(text); - if (groupIndex !== undefined) { - // deduplicate/group entries in dependency list by the dependency name - dependencyGroups[groupIndex].externalImports.push(externalImport); - } - else { - groupIndices.set(text, dependencyGroups.length); - dependencyGroups.push({ - name: externalModuleName, - externalImports: [externalImport] - }); + if (externalModuleName) { + const text = externalModuleName.text; + const groupIndex = groupIndices.get(text); + if (groupIndex !== undefined) { + // deduplicate/group entries in dependency list by the dependency name + dependencyGroups[groupIndex].externalImports.push(externalImport); + } + else { + groupIndices.set(text, dependencyGroups.length); + dependencyGroups.push({ + name: externalModuleName, + externalImports: [externalImport] + }); + } } } @@ -1287,6 +1289,10 @@ namespace ts { * @param node The node to visit. */ function visitForInitializer(node: ForInitializer): ForInitializer { + if (!node) { + return node; + } + if (shouldHoistForInitializer(node)) { let expressions: Expression[]; for (const variable of node.declarations) { diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 885f8fad898fd..8df760d51c08c 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -2049,6 +2049,7 @@ namespace ts { visitNodes(node.modifiers, modifierVisitor, isModifier), node.asteriskToken, visitPropertyNameOfClassElement(node), + /*questionToken*/ undefined, /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), /*type*/ undefined, @@ -2323,13 +2324,13 @@ namespace ts { // code if the casted expression has a lower precedence than the rest of the // expression. // + // To preserve comments, we return a "PartiallyEmittedExpression" here which will + // preserve the position information of the original expression. + // // Due to the auto-parenthesization rules used by the visitor and factory functions // we can safely elide the parentheses here, as a new synthetic // ParenthesizedExpression will be inserted if we remove parentheses too // aggressively. - // - // To preserve comments, we return a "PartiallyEmittedExpression" here which will - // preserve the position information of the original expression. return createPartiallyEmittedExpression(expression, node); } diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts index 4fd3ecb02bb3c..780937a080c23 100644 --- a/src/compiler/tsc.ts +++ b/src/compiler/tsc.ts @@ -336,7 +336,7 @@ namespace ts { // is an absolute file name. directory == "" ? "." : directory, watchedDirectoryChanged, /*recursive*/ true); - }; + } } return configParseResult; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index ceeb2922d422e..0fd01c7b4782a 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -819,7 +819,7 @@ namespace ts { body?: FunctionBody; } - // For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. + /** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */ export interface SemicolonClassElement extends ClassElement { kind: SyntaxKind.SemicolonClassElement; parent?: ClassDeclaration | ClassExpression; @@ -861,7 +861,11 @@ namespace ts { | SyntaxKind.BooleanKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword - | SyntaxKind.VoidKeyword; + | SyntaxKind.ThisKeyword + | SyntaxKind.VoidKeyword + | SyntaxKind.UndefinedKeyword + | SyntaxKind.NullKeyword + | SyntaxKind.NeverKeyword; } export interface ThisTypeNode extends TypeNode { @@ -1030,15 +1034,15 @@ namespace ts { _primaryExpressionBrand: any; } - export interface NullLiteral extends PrimaryExpression { + export interface NullLiteral extends PrimaryExpression, TypeNode { kind: SyntaxKind.NullKeyword; } - export interface BooleanLiteral extends PrimaryExpression { + export interface BooleanLiteral extends PrimaryExpression, TypeNode { kind: SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword; } - export interface ThisExpression extends PrimaryExpression { + export interface ThisExpression extends PrimaryExpression, KeywordTypeNode { kind: SyntaxKind.ThisKeyword; } @@ -1309,8 +1313,6 @@ namespace ts { text: string; isUnterminated?: boolean; hasExtendedUnicodeEscape?: boolean; - /* @internal */ - isOctalLiteral?: boolean; } // The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral, @@ -1328,8 +1330,21 @@ namespace ts { kind: SyntaxKind.NoSubstitutionTemplateLiteral; } + /* @internal */ + export const enum NumericLiteralFlags { + None = 0, + Scientific = 1 << 1, // e.g. `10e2` + Octal = 1 << 2, // e.g. `0777` + HexSpecifier = 1 << 3, // e.g. `0x00000000` + BinarySpecifier = 1 << 4, // e.g. `0b0110010000000000` + OctalSpecifier = 1 << 5, // e.g. `0o777` + BinaryOrOctalSpecifier = BinarySpecifier | OctalSpecifier, + } + export interface NumericLiteral extends LiteralExpression { kind: SyntaxKind.NumericLiteral; + /* @internal */ + numericLiteralFlags?: NumericLiteralFlags; } export interface TemplateHead extends LiteralLikeNode { @@ -1382,11 +1397,11 @@ namespace ts { } /** - * This interface is a base interface for ObjectLiteralExpression and JSXAttributes to extend from. JSXAttributes is similar to - * ObjectLiteralExpression in that it contains array of properties; however, JSXAttributes' properties can only be - * JSXAttribute or JSXSpreadAttribute. ObjectLiteralExpression, on the other hand, can only have properties of type - * ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.) - **/ + * This interface is a base interface for ObjectLiteralExpression and JSXAttributes to extend from. JSXAttributes is similar to + * ObjectLiteralExpression in that it contains array of properties; however, JSXAttributes' properties can only be + * JSXAttribute or JSXSpreadAttribute. ObjectLiteralExpression, on the other hand, can only have properties of type + * ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.) + */ export interface ObjectLiteralExpressionBase extends PrimaryExpression, Declaration { properties: NodeArray; } @@ -1398,7 +1413,7 @@ namespace ts { multiLine?: boolean; } - export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression; + export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression | ParenthesizedExpression; export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression; export interface PropertyAccessExpression extends MemberExpression, Declaration { @@ -1948,6 +1963,10 @@ namespace ts { fileName: string; } + export interface CheckJsDirective extends TextRange { + enabled: boolean; + } + export type CommentKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia; export interface CommentRange extends TextRange { @@ -2290,6 +2309,7 @@ namespace ts { /* @internal */ moduleAugmentations: LiteralExpression[]; /* @internal */ patternAmbientModules?: PatternAmbientModule[]; /* @internal */ ambientModuleNames: string[]; + /* @internal */ checkJsDirective: CheckJsDirective | undefined; } export interface Bundle extends Node { @@ -2310,9 +2330,9 @@ namespace ts { readDirectory(rootDir: string, extensions: string[], excludes: string[], includes: string[]): string[]; /** - * Gets a value indicating whether the specified path exists and is a file. - * @param path The path to test. - */ + * Gets a value indicating whether the specified path exists and is a file. + * @param path The path to test. + */ fileExists(path: string): boolean; readFile(path: string): string; @@ -2472,6 +2492,14 @@ namespace ts { /* @internal */ getParameterType(signature: Signature, parameterIndex: number): Type; getNonNullableType(type: Type): Type; + /** Note that the resulting nodes cannot be checked. */ + + typeToTypeNode(type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): TypeNode; + /** Note that the resulting nodes cannot be checked. */ + signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): SignatureDeclaration; + /** Note that the resulting nodes cannot be checked. */ + indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, kind: IndexKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): IndexSignatureDeclaration; + getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; getSymbolAtLocation(node: Node): Symbol; getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[]; @@ -2512,6 +2540,100 @@ namespace ts { /* @internal */ tryFindAmbientModuleWithoutAugmentations(moduleName: string): Symbol; + /** + * Two types are considered identical when + * - they are both the `any` type, + * - they are the same primitive type, + * - they are the same type parameter, + * - they are union types with identical sets of constituent types, or + * - they are intersection types with identical sets of constituent types, or + * - they are object types with identical sets of members. + * + * This relationship is bidirectional. + * See [here](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#3.11.2) for more information. + */ + isIdenticalTo(a: Type, b: Type): boolean; + /** + * `a` is a ___subtype___ of `b` (and `b` is a ___supertype___ of `a`) if `a` has no excess properties with respect to `b`, + * and one of the following is true: + * - `a` and `b` are identical types. + * - `b` is the `any` type. + * - `a` is the `undefined` type. + * - `a` is the `null` type and `b` is _not_ the `undefined` type. + * - `a` is an enum type and `b` is the primitive type `number`. + * - `a` is a string literal type and `b` is the primitive type `string`. + * - `a` is a union type and each constituient type of `b` is a subtype of `b`. + * - `a` is an intersection type and at least one constituent type of `a` is a subtype of `b`. + * - `b` is a union type and `a` is a subtype of at least one constituent type of `b`. + * - `b` is an intersection type and `a` is a subtype of each constituent type of `b`. + * - `a` is a type parameter and the constraint of `a` is a subtype of `b`. + * - `a` has a subset of the structural members of `b`. + * + * This relationship is directional. + * See [here](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#3.11.3) for more information. + */ + isSubtypeOf(a: Type, b: Type): boolean; + /** + * The assignable relationship differs only from the subtype relationship in that: + * - the `any` type is assignable to, but not a subtype of, all types + * - the primitive type `number` is assignable to, but not a subtype of, all enum types, and + * - an object type without a particular property is assignable to an object type in which that property is optional. + * + * This relationship is directional. + * See [here](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#3.11.4) for more information. + */ + isAssignableTo(a: Type, b: Type): boolean; + /** + * True if `a` is assignable to `b`, or `b` is assignable to `a`. Additionally, all unions with + * overlapping constituient types are comparable, and unit types in the same domain are comparable. + * This relationship is bidirectional. + */ + isComparableTo(a: Type, b: Type): boolean; + /** + * Not a formal relationship - returns true if a is an instantiation of the generic type b + */ + isInstantiationOf(a: GenericType, b: GenericType): boolean; + + /** + * Returns the declared type of the globally named symbol with meaning SymbolFlags.Type + * Returns the unknown type on failure. + */ + lookupGlobalType(name: string): Type; + /** + * Returns the declared type of the globally named symbol with meaning SymbolFlags.Value + * Returns the unknown type on failure. + */ + lookupGlobalValueType(name: string): Type; + /** + * Returns the declared type of the named symbol lexically at the position specified with meaning SymbolFlags.Type + * Returns the unknown type on failure. + */ + lookupTypeAt(name: string, position: Node): Type; + /** + * Returns the declared type of the named symbol lexically at the position specified with meaning SymbolFlags.Value + * Returns the unknown type on failure. + */ + lookupValueTypeAt(name: string, position: Node): Type; + /** + * Returns the type of a symbol + */ + getTypeOfSymbol(symbol: Symbol): Type; + + getAnyType(): Type; + getStringType(): Type; + getNumberType(): Type; + getBooleanType(): Type; + getVoidType(): Type; + getUndefinedType(): Type; + getNullType(): Type; + getESSymbolType(): Type; + getNeverType(): Type; + getUnknownType(): Type; + getStringLiteralType(text: string): LiteralType; + getNumberLiteralType(text: string): LiteralType; + getFalseType(): Type; + getTrueType(): Type; + // Should not be called directly. Should only be accessed through the Program instance. /* @internal */ getDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[]; /* @internal */ getGlobalDiagnostics(): Diagnostic[]; @@ -2523,6 +2645,16 @@ namespace ts { /* @internal */ getTypeCount(): number; } + export enum NodeBuilderFlags { + None = 0, + allowThisInObjectLiteral = 1 << 0, + allowQualifedNameInPlaceOfIdentifier = 1 << 1, + allowTypeParameterInQualifiedName = 1 << 2, + allowAnonymousIdentifier = 1 << 3, + allowEmptyUnionOrIntersection = 1 << 4, + allowEmptyTuple = 1 << 5 + } + export interface SymbolDisplayBuilder { buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void; @@ -2642,8 +2774,7 @@ namespace ts { errorModuleName?: string; // If the symbol is not visible from module, module's name } - /** Indicates how to serialize the name for a TypeReferenceNode when emitting decorator - * metadata */ + /** Indicates how to serialize the name for a TypeReferenceNode when emitting decorator metadata */ /* @internal */ export enum TypeReferenceSerializationKind { Unknown, // The TypeReferenceNode could not be resolved. The type name @@ -2843,6 +2974,7 @@ namespace ts { /* @internal */ export interface TransientSymbol extends Symbol, SymbolLinks { checkFlags: CheckFlags; + isRestParameter?: boolean; } export type SymbolTable = Map; @@ -2872,7 +3004,7 @@ namespace ts { ContextChecked = 0x00000400, // Contextual types have been assigned AsyncMethodWithSuper = 0x00000800, // An async method that reads a value from a member of 'super'. AsyncMethodWithSuperBinding = 0x00001000, // An async method that assigns a value to a member of 'super'. - CaptureArguments = 0x00002000, // Lexical 'arguments' used in body (for async functions) + CaptureArguments = 0x00002000, // Lexical 'arguments' used in body EnumValuesComputed = 0x00004000, // Values for enum members have been computed, and any errors have been reported for them. LexicalModuleMergesWithClass = 0x00008000, // Instantiated lexical module declaration is merged with a previous class declaration. LoopWithCapturedBlockScopedBinding = 0x00010000, // Loop that contains block scoped variable captured in closure @@ -2896,6 +3028,7 @@ namespace ts { maybeTypePredicate?: boolean; // Cached check whether call expression might reference a type predicate enumMemberValue?: number; // Constant value of enum member isVisible?: boolean; // Is this node visible + containsArgumentsReference?: boolean; // Whether a function-like declaration contains an 'arguments' reference hasReportedStatementInAmbientContext?: boolean; // Cache boolean if we report statements in ambient context jsxFlags?: JsxFlags; // flags for knowing what kind of element/attributes we're dealing with resolvedJsxElementAttributesType?: Type; // resolved element attributes type of a JSX openinglike element @@ -3333,6 +3466,7 @@ namespace ts { alwaysStrict?: boolean; // Always combine with strict property baseUrl?: string; charset?: string; + checkJs?: boolean; /* @internal */ configFilePath?: string; declaration?: boolean; declarationDir?: string; @@ -4073,7 +4207,7 @@ namespace ts { export type Transformer = (node: T) => T; /** - * A function that accepts and possible transforms a node. + * A function that accepts and possibly transforms a node. */ export type Visitor = (node: Node) => VisitResult; @@ -4159,7 +4293,6 @@ namespace ts { } export interface PrinterOptions { - target?: ScriptTarget; removeComments?: boolean; newLine?: NewLineKind; /*@internal*/ sourceMap?: boolean; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 48d90bbca51db..911c0d67ebe26 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -322,21 +322,11 @@ namespace ts { return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia); } - export function getLiteralText(node: LiteralLikeNode, sourceFile: SourceFile, languageVersion: ScriptTarget) { - // Any template literal or string literal with an extended escape - // (e.g. "\u{0067}") will need to be downleveled as a escaped string literal. - if (languageVersion < ScriptTarget.ES2015 && (isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) { - return getQuotedEscapedLiteralText('"', node.text, '"'); - } - + export function getLiteralText(node: LiteralLikeNode, sourceFile: SourceFile) { // If we don't need to downlevel and we can reach the original source text using // the node's parent reference, then simply get the text as it was originally written. if (!nodeIsSynthesized(node) && node.parent) { - const text = getSourceTextOfNodeFromSourceFile(sourceFile, node); - if (languageVersion < ScriptTarget.ES2015 && isBinaryOrOctalIntegerLiteral(node, text)) { - return node.text; - } - return text; + return getSourceTextOfNodeFromSourceFile(sourceFile, node); } // If we can't reach the original source text, use the canonical form if it's a number, @@ -359,55 +349,6 @@ namespace ts { Debug.fail(`Literal kind '${node.kind}' not accounted for.`); } - export function isBinaryOrOctalIntegerLiteral(node: LiteralLikeNode, text: string) { - return node.kind === SyntaxKind.NumericLiteral - && (getNumericLiteralFlags(text, /*hint*/ NumericLiteralFlags.BinaryOrOctal) & NumericLiteralFlags.BinaryOrOctal) !== 0; - } - - export const enum NumericLiteralFlags { - None = 0, - Hexadecimal = 1 << 0, - Binary = 1 << 1, - Octal = 1 << 2, - Scientific = 1 << 3, - - BinaryOrOctal = Binary | Octal, - BinaryOrOctalOrHexadecimal = BinaryOrOctal | Hexadecimal, - All = Hexadecimal | Binary | Octal | Scientific, - } - - /** - * Scans a numeric literal string to determine the form of the number. - * @param text Numeric literal text - * @param hint If `Scientific` or `All` is specified, performs a more expensive check to scan for scientific notation. - */ - export function getNumericLiteralFlags(text: string, hint?: NumericLiteralFlags) { - if (text.length > 1) { - switch (text.charCodeAt(1)) { - case CharacterCodes.b: - case CharacterCodes.B: - return NumericLiteralFlags.Binary; - case CharacterCodes.o: - case CharacterCodes.O: - return NumericLiteralFlags.Octal; - case CharacterCodes.x: - case CharacterCodes.X: - return NumericLiteralFlags.Hexadecimal; - } - - if (hint & NumericLiteralFlags.Scientific) { - for (let i = text.length - 1; i >= 0; i--) { - switch (text.charCodeAt(i)) { - case CharacterCodes.e: - case CharacterCodes.E: - return NumericLiteralFlags.Scientific; - } - } - } - } - return NumericLiteralFlags.None; - } - function getQuotedEscapedLiteralText(leftQuote: string, text: string, rightQuote: string) { return leftQuote + escapeNonAsciiCharacters(escapeString(text)) + rightQuote; } @@ -438,9 +379,9 @@ namespace ts { ((node).name.kind === SyntaxKind.StringLiteral || isGlobalScopeAugmentation(node)); } - /** Given a symbol for a module, checks that it is either an untyped import or a shorthand ambient module. */ - export function isUntypedOrShorthandAmbientModuleSymbol(moduleSymbol: Symbol): boolean { - return !moduleSymbol.declarations || isShorthandAmbientModule(moduleSymbol.valueDeclaration); + /** Given a symbol for a module, checks that it is a shorthand ambient module. */ + export function isShorthandAmbientModuleSymbol(moduleSymbol: Symbol): boolean { + return isShorthandAmbientModule(moduleSymbol.valueDeclaration); } function isShorthandAmbientModule(node: Node): boolean { @@ -525,6 +466,10 @@ namespace ts { return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); } + export function getNameFromIndexInfo(info: IndexInfo) { + return info.declaration ? declarationNameToString(info.declaration.parameters[0].name) : undefined; + } + export function getTextOfPropertyName(name: PropertyName): string { switch (name.kind) { case SyntaxKind.Identifier: @@ -740,8 +685,8 @@ namespace ts { // // let a: A.B.C; // - // Calling isPartOfTypeNode would consider the qualified name A.B a type node. Only C or - // A.B.C is a type node. + // Calling isPartOfTypeNode would consider the qualified name A.B a type node. + // Only C and A.B.C are type nodes. if (SyntaxKind.FirstTypeNode <= parent.kind && parent.kind <= SyntaxKind.LastTypeNode) { return true; } @@ -1091,13 +1036,13 @@ namespace ts { } /** - * Given an super call/property node, returns the closest node where - * - a super call/property access is legal in the node and not legal in the parent node the node. - * i.e. super call is legal in constructor but not legal in the class body. - * - the container is an arrow function (so caller might need to call getSuperContainer again in case it needs to climb higher) - * - a super call/property is definitely illegal in the container (but might be legal in some subnode) - * i.e. super property access is illegal in function declaration but can be legal in the statement list - */ + * Given an super call/property node, returns the closest node where + * - a super call/property access is legal in the node and not legal in the parent node the node. + * i.e. super call is legal in constructor but not legal in the class body. + * - the container is an arrow function (so caller might need to call getSuperContainer again in case it needs to climb higher) + * - a super call/property is definitely illegal in the container (but might be legal in some subnode) + * i.e. super property access is illegal in function declaration but can be legal in the statement list + */ export function getSuperContainer(node: Node, stopOnFunctions: boolean): Node { while (true) { node = node.parent; @@ -1400,17 +1345,24 @@ namespace ts { /** * Returns true if the node is a CallExpression to the identifier 'require' with - * exactly one argument. + * exactly one argument (of the form 'require("name")'). * This function does not test if the node is in a JavaScript file or not. - */ - export function isRequireCall(expression: Node, checkArgumentIsStringLiteral: boolean): expression is CallExpression { - // of the form 'require("name")' - const isRequire = expression.kind === SyntaxKind.CallExpression && - (expression).expression.kind === SyntaxKind.Identifier && - ((expression).expression).text === "require" && - (expression).arguments.length === 1; + */ + export function isRequireCall(callExpression: Node, checkArgumentIsStringLiteral: boolean): callExpression is CallExpression { + if (callExpression.kind !== SyntaxKind.CallExpression) { + return false; + } + const { expression, arguments: args } = callExpression as CallExpression; + + if (expression.kind !== SyntaxKind.Identifier || (expression as Identifier).text !== "require") { + return false; + } - return isRequire && (!checkArgumentIsStringLiteral || (expression).arguments[0].kind === SyntaxKind.StringLiteral); + if (args.length !== 1) { + return false; + } + const arg = args[0]; + return !checkArgumentIsStringLiteral || arg.kind === SyntaxKind.StringLiteral || arg.kind === SyntaxKind.NoSubstitutionTemplateLiteral; } export function isSingleOrDoubleQuote(charCode: number) { @@ -1446,13 +1398,10 @@ namespace ts { /// Given a BinaryExpression, returns SpecialPropertyAssignmentKind for the various kinds of property /// assignments we treat as special in the binder - export function getSpecialPropertyAssignmentKind(expression: Node): SpecialPropertyAssignmentKind { + export function getSpecialPropertyAssignmentKind(expression: ts.BinaryExpression): SpecialPropertyAssignmentKind { if (!isInJavaScriptFile(expression)) { return SpecialPropertyAssignmentKind.None; } - if (expression.kind !== SyntaxKind.BinaryExpression) { - return SpecialPropertyAssignmentKind.None; - } const expr = expression; if (expr.operatorToken.kind !== SyntaxKind.EqualsToken || expr.left.kind !== SyntaxKind.PropertyAccessExpression) { return SpecialPropertyAssignmentKind.None; @@ -1587,7 +1536,7 @@ namespace ts { return node && firstOrUndefined(getJSDocTags(node, kind)); } - function getJSDocs(node: Node): (JSDoc | JSDocTag)[] { + export function getJSDocs(node: Node): (JSDoc | JSDocTag)[] { let cache: (JSDoc | JSDocTag)[] = node.jsDocCache; if (!cache) { getJSDocsWorker(node); @@ -2019,6 +1968,10 @@ namespace ts { return false; } + export function isNumericLiteral(node: Node): node is NumericLiteral { + return node.kind === SyntaxKind.NumericLiteral; + } + export function isStringOrNumericLiteral(node: Node): node is StringLiteral | NumericLiteral { const kind = node.kind; return kind === SyntaxKind.StringLiteral @@ -3713,10 +3666,14 @@ namespace ts { return (kind >= SyntaxKind.FirstTypeNode && kind <= SyntaxKind.LastTypeNode) || kind === SyntaxKind.AnyKeyword || kind === SyntaxKind.NumberKeyword + || kind === SyntaxKind.ObjectKeyword || kind === SyntaxKind.BooleanKeyword || kind === SyntaxKind.StringKeyword || kind === SyntaxKind.SymbolKeyword + || kind === SyntaxKind.ThisKeyword || kind === SyntaxKind.VoidKeyword + || kind === SyntaxKind.UndefinedKeyword + || kind === SyntaxKind.NullKeyword || kind === SyntaxKind.NeverKeyword || kind === SyntaxKind.ExpressionWithTypeArguments; } @@ -4542,9 +4499,9 @@ namespace ts { } /** - * Checks to see if the locale is in the appropriate format, - * and if it is, attempts to set the appropriate language. - */ + * Checks to see if the locale is in the appropriate format, + * and if it is, attempts to set the appropriate language. + */ export function validateLocaleAndSetLanguage( locale: string, sys: { getExecutingFilePath(): string, resolvePath(path: string): string, fileExists(fileName: string): boolean, readFile(fileName: string): string }, diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts index 133c62e192624..297d2cc0dde3c 100644 --- a/src/compiler/visitor.ts +++ b/src/compiler/visitor.ts @@ -204,21 +204,17 @@ namespace ts { * @param visitor The callback used to visit each child. * @param context A lexical environment context for the visitor. */ - export function visitEachChild(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes): T | undefined; + export function visitEachChild(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes, tokenVisitor?: Visitor): T | undefined; - export function visitEachChild(node: Node, visitor: Visitor, context: TransformationContext, nodesVisitor = visitNodes): Node { + export function visitEachChild(node: Node, visitor: Visitor, context: TransformationContext, nodesVisitor = visitNodes, tokenVisitor?: Visitor): Node { if (node === undefined) { return undefined; } const kind = node.kind; - // No need to visit nodes with no children. - if ((kind > SyntaxKind.FirstToken && kind <= SyntaxKind.LastToken)) { - return node; - } - // We do not yet support types. - if ((kind >= SyntaxKind.TypePredicate && kind <= SyntaxKind.LiteralType)) { + // No need to visit nodes with no children. + if ((kind > SyntaxKind.FirstToken && kind <= SyntaxKind.LastToken) || kind === SyntaxKind.ThisType) { return node; } @@ -227,6 +223,8 @@ namespace ts { case SyntaxKind.EmptyStatement: case SyntaxKind.OmittedExpression: case SyntaxKind.DebuggerStatement: + case SyntaxKind.EndOfDeclarationMarker: + case SyntaxKind.MissingDeclaration: // No need to visit nodes with no children. return node; @@ -240,13 +238,53 @@ namespace ts { return updateComputedPropertyName(node, visitNode((node).expression, visitor, isExpression)); - // Signature elements + // Signatures and Signature Elements + case SyntaxKind.FunctionType: + return updateFunctionTypeNode(node, + nodesVisitor((node).typeParameters, visitor, isTypeParameter), + visitParameterList((node).parameters, visitor, context, nodesVisitor), + visitNode((node).type, visitor, isTypeNode)); + + case SyntaxKind.ConstructorType: + return updateConstructorTypeNode(node, + nodesVisitor((node).typeParameters, visitor, isTypeParameter), + visitParameterList((node).parameters, visitor, context, nodesVisitor), + visitNode((node).type, visitor, isTypeNode)); + + case SyntaxKind.CallSignature: + return updateCallSignatureDeclaration(node, + nodesVisitor((node).typeParameters, visitor, isTypeParameter), + visitParameterList((node).parameters, visitor, context, nodesVisitor), + visitNode((node).type, visitor, isTypeNode)); + + case SyntaxKind.ConstructSignature: + return updateConstructSignatureDeclaration(node, + nodesVisitor((node).typeParameters, visitor, isTypeParameter), + visitParameterList((node).parameters, visitor, context, nodesVisitor), + visitNode((node).type, visitor, isTypeNode)); + + case SyntaxKind.MethodSignature: + return updateMethodSignature(node, + nodesVisitor((node).typeParameters, visitor, isTypeParameter), + visitParameterList((node).parameters, visitor, context, nodesVisitor), + visitNode((node).type, visitor, isTypeNode), + visitNode((node).name, visitor, isPropertyName), + visitNode((node).questionToken, tokenVisitor, isToken)); + + case SyntaxKind.IndexSignature: + return updateIndexSignatureDeclaration(node, + nodesVisitor((node).decorators, visitor, isDecorator), + nodesVisitor((node).modifiers, visitor, isModifier), + visitParameterList((node).parameters, visitor, context, nodesVisitor), + visitNode((node).type, visitor, isTypeNode)); + case SyntaxKind.Parameter: return updateParameter(node, nodesVisitor((node).decorators, visitor, isDecorator), nodesVisitor((node).modifiers, visitor, isModifier), - (node).dotDotDotToken, + visitNode((node).dotDotDotToken, tokenVisitor, isToken), visitNode((node).name, visitor, isBindingName), + visitNode((node).questionToken, tokenVisitor, isToken), visitNode((node).type, visitor, isTypeNode), visitNode((node).initializer, visitor, isExpression)); @@ -254,7 +292,74 @@ namespace ts { return updateDecorator(node, visitNode((node).expression, visitor, isExpression)); - // Type member + // Types + + case SyntaxKind.TypeReference: + return updateTypeReferenceNode(node, + visitNode((node).typeName, visitor, isEntityName), + nodesVisitor((node).typeArguments, visitor, isTypeNode)); + + case SyntaxKind.TypePredicate: + return updateTypePredicateNode(node, + visitNode((node).parameterName, visitor), + visitNode((node).type, visitor, isTypeNode)); + + case SyntaxKind.TypeQuery: + return updateTypeQueryNode((node), visitNode((node).exprName, visitor, isEntityName)); + + case SyntaxKind.TypeLiteral: + return updateTypeLiteralNode((node), nodesVisitor((node).members, visitor)); + + case SyntaxKind.ArrayType: + return updateArrayTypeNode(node, visitNode((node).elementType, visitor, isTypeNode)); + + case SyntaxKind.TupleType: + return updateTypleTypeNode((node), nodesVisitor((node).elementTypes, visitor, isTypeNode)); + + case SyntaxKind.UnionType: + case SyntaxKind.IntersectionType: + return updateUnionOrIntersectionTypeNode(node, + nodesVisitor((node).types, visitor, isTypeNode)); + + case SyntaxKind.ParenthesizedType: + Debug.fail("not implemented."); + + case SyntaxKind.TypeOperator: + return updateTypeOperatorNode(node, visitNode((node).type, visitor, isTypeNode)); + + case SyntaxKind.IndexedAccessType: + return updateIndexedAccessTypeNode((node), + visitNode((node).objectType, visitor, isTypeNode), + visitNode((node).indexType, visitor, isTypeNode)); + + case SyntaxKind.MappedType: + return updateMappedTypeNode((node), + visitNode((node).readonlyToken, tokenVisitor, isToken), + visitNode((node).typeParameter, visitor, isTypeParameter), + visitNode((node).questionToken, tokenVisitor, isToken), + visitNode((node).type, visitor, isTypeNode)); + + case SyntaxKind.LiteralType: + return updateLiteralTypeNode(node, + visitNode((node).literal, visitor, isExpression)); + + // Type Declarations + + case SyntaxKind.TypeParameter: + return updateTypeParameterDeclaration(node, + visitNode((node).name, visitor, isIdentifier), + visitNode((node).constraint, visitor, isTypeNode), + visitNode((node).default, visitor, isTypeNode)); + + // Type members + + case SyntaxKind.PropertySignature: + return updatePropertySignature((node), + visitNode((node).name, visitor, isPropertyName), + visitNode((node).questionToken, tokenVisitor, isToken), + visitNode((node).type, visitor, isTypeNode), + visitNode((node).initializer, visitor, isExpression)); + case SyntaxKind.PropertyDeclaration: return updateProperty(node, nodesVisitor((node).decorators, visitor, isDecorator), @@ -267,8 +372,9 @@ namespace ts { return updateMethod(node, nodesVisitor((node).decorators, visitor, isDecorator), nodesVisitor((node).modifiers, visitor, isModifier), - (node).asteriskToken, + visitNode((node).asteriskToken, tokenVisitor, isToken), visitNode((node).name, visitor, isPropertyName), + visitNode((node).questionToken, tokenVisitor, isToken), nodesVisitor((node).typeParameters, visitor, isTypeParameter), visitParameterList((node).parameters, visitor, context, nodesVisitor), visitNode((node).type, visitor, isTypeNode), @@ -309,7 +415,7 @@ namespace ts { case SyntaxKind.BindingElement: return updateBindingElement(node, - (node).dotDotDotToken, + visitNode((node).dotDotDotToken, tokenVisitor, isToken), visitNode((node).propertyName, visitor, isPropertyName), visitNode((node).name, visitor, isBindingName), visitNode((node).initializer, visitor, isExpression)); @@ -362,7 +468,7 @@ namespace ts { case SyntaxKind.FunctionExpression: return updateFunctionExpression(node, nodesVisitor((node).modifiers, visitor, isModifier), - (node).asteriskToken, + visitNode((node).asteriskToken, tokenVisitor, isToken), visitNode((node).name, visitor, isIdentifier), nodesVisitor((node).typeParameters, visitor, isTypeParameter), visitParameterList((node).parameters, visitor, context, nodesVisitor), @@ -419,7 +525,7 @@ namespace ts { case SyntaxKind.YieldExpression: return updateYield(node, - (node).asteriskToken, + visitNode((node).asteriskToken, tokenVisitor, isToken), visitNode((node).expression, visitor, isExpression)); case SyntaxKind.SpreadElement: @@ -555,7 +661,7 @@ namespace ts { return updateFunctionDeclaration(node, nodesVisitor((node).decorators, visitor, isDecorator), nodesVisitor((node).modifiers, visitor, isModifier), - (node).asteriskToken, + visitNode((node).asteriskToken, tokenVisitor, isToken), visitNode((node).name, visitor, isIdentifier), nodesVisitor((node).typeParameters, visitor, isTypeParameter), visitParameterList((node).parameters, visitor, context, nodesVisitor), diff --git a/src/harness/compilerRunner.ts b/src/harness/compilerRunner.ts index 327932f366703..d0eee02efd7bf 100644 --- a/src/harness/compilerRunner.ts +++ b/src/harness/compilerRunner.ts @@ -51,7 +51,7 @@ class CompilerBaselineRunner extends RunnerBase { const path = ts.toPath(name, root, (fileName) => Harness.Compiler.getCanonicalFileName(fileName)); const pathStart = ts.toPath(Harness.IO.getCurrentDirectory(), "", (fileName) => Harness.Compiler.getCanonicalFileName(fileName)); return pathStart ? path.replace(pathStart, "/") : path; - }; + } public checkTestCodeOutput(fileName: string) { describe("compiler tests for " + fileName, () => { diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 98ebacd49b126..32963b30a0ab2 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -858,7 +858,7 @@ namespace FourSlash { } } - public verifyCompletionEntryDetails(entryName: string, expectedText: string, expectedDocumentation?: string, kind?: string) { + public verifyCompletionEntryDetails(entryName: string, expectedText: string, expectedDocumentation?: string, kind?: string, tags?: ts.JSDocTagInfo[]) { const details = this.getCompletionEntryDetails(entryName); assert(details, "no completion entry available"); @@ -872,6 +872,14 @@ namespace FourSlash { if (kind !== undefined) { assert.equal(details.kind, kind, this.assertionMessageAtLastKnownMarker("completion entry kind")); } + + if (tags !== undefined) { + assert.equal(details.tags.length, tags.length, this.messageAtLastKnownMarker("QuickInfo tags")); + ts.zipWith(tags, details.tags, (expectedTag, actualTag) => { + assert.equal(expectedTag.name, actualTag.name); + assert.equal(expectedTag.text, actualTag.text, this.messageAtLastKnownMarker("QuickInfo tag " + actualTag.name)); + }); + } } public verifyReferencesAre(expectedReferences: Range[]) { @@ -1083,7 +1091,9 @@ namespace FourSlash { public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: { start: number; length: number; }, displayParts: ts.SymbolDisplayPart[], - documentation: ts.SymbolDisplayPart[]) { + documentation: ts.SymbolDisplayPart[], + tags: ts.JSDocTagInfo[] + ) { const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition); assert.equal(actualQuickInfo.kind, kind, this.messageAtLastKnownMarker("QuickInfo kind")); @@ -1091,6 +1101,11 @@ namespace FourSlash { assert.equal(JSON.stringify(actualQuickInfo.textSpan), JSON.stringify(textSpan), this.messageAtLastKnownMarker("QuickInfo textSpan")); assert.equal(TestState.getDisplayPartsJson(actualQuickInfo.displayParts), TestState.getDisplayPartsJson(displayParts), this.messageAtLastKnownMarker("QuickInfo displayParts")); assert.equal(TestState.getDisplayPartsJson(actualQuickInfo.documentation), TestState.getDisplayPartsJson(documentation), this.messageAtLastKnownMarker("QuickInfo documentation")); + assert.equal(actualQuickInfo.tags.length, tags.length, this.messageAtLastKnownMarker("QuickInfo tags")); + ts.zipWith(tags, actualQuickInfo.tags, (expectedTag, actualTag) => { + assert.equal(expectedTag.name, actualTag.name); + assert.equal(expectedTag.text, actualTag.text, this.messageAtLastKnownMarker("QuickInfo tag " + actualTag.name)); + }); } public verifyRenameLocations(findInStrings: boolean, findInComments: boolean, ranges?: Range[]) { @@ -1184,6 +1199,16 @@ namespace FourSlash { assert.equal(ts.displayPartsToString(actualDocComment), docComment, this.assertionMessageAtLastKnownMarker("current signature help doc comment")); } + public verifyCurrentSignatureHelpTags(tags: ts.JSDocTagInfo[]) { + const actualTags = this.getActiveSignatureHelpItem().tags; + + assert.equal(actualTags.length, tags.length, this.assertionMessageAtLastKnownMarker("signature help tags")); + ts.zipWith(tags, actualTags, (expectedTag, actualTag) => { + assert.equal(expectedTag.name, actualTag.name); + assert.equal(expectedTag.text, actualTag.text, this.assertionMessageAtLastKnownMarker("signature help tag " + actualTag.name)); + }); + } + public verifySignatureHelpCount(expected: number) { const help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition); const actual = help && help.items ? help.items.length : 0; @@ -1669,7 +1694,7 @@ namespace FourSlash { if (ch === "\r") { this.currentCaretPosition--; } - }; + } } private applyEdits(fileName: string, edits: ts.TextChange[], isFormattingEdit = false): number { @@ -2180,7 +2205,7 @@ namespace FourSlash { /** * Applies fixes for the errors in fileName and compares the results to * expectedContents after all fixes have been applied. - + * * Note: applying one codefix may generate another (eg: remove duplicate implements * may generate an extends -> interface conversion fix). * @param expectedContents The contents of the file after the fixes are applied. @@ -2584,6 +2609,11 @@ namespace FourSlash { } } + public printAvailableCodeFixes() { + const codeFixes = this.getCodeFixActions(this.activeFile.fileName); + Harness.IO.log(stringify(codeFixes)); + } + // Get the text of the entire line the caret is currently at private getCurrentLineContent() { const text = this.getFileContent(this.activeFile.fileName); @@ -3509,6 +3539,10 @@ namespace FourSlashInterface { this.state.verifyCurrentSignatureHelpDocComment(docComment); } + public currentSignatureHelpTagsAre(tags: ts.JSDocTagInfo[]) { + this.state.verifyCurrentSignatureHelpTags(tags); + } + public signatureHelpCountIs(expected: number) { this.state.verifySignatureHelpCount(expected); } @@ -3637,8 +3671,8 @@ namespace FourSlashInterface { this.state.verifyRangesWithSameTextAreDocumentHighlights(); } - public completionEntryDetailIs(entryName: string, text: string, documentation?: string, kind?: string) { - this.state.verifyCompletionEntryDetails(entryName, text, documentation, kind); + public completionEntryDetailIs(entryName: string, text: string, documentation?: string, kind?: string, tags?: ts.JSDocTagInfo[]) { + this.state.verifyCompletionEntryDetails(entryName, text, documentation, kind, tags); } /** @@ -3668,8 +3702,8 @@ namespace FourSlashInterface { } public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: { start: number; length: number; }, - displayParts: ts.SymbolDisplayPart[], documentation: ts.SymbolDisplayPart[]) { - this.state.verifyQuickInfoDisplayParts(kind, kindModifiers, textSpan, displayParts, documentation); + displayParts: ts.SymbolDisplayPart[], documentation: ts.SymbolDisplayPart[], tags: ts.JSDocTagInfo[]) { + this.state.verifyQuickInfoDisplayParts(kind, kindModifiers, textSpan, displayParts, documentation, tags); } public getSyntacticDiagnostics(expected: string) { @@ -3772,6 +3806,10 @@ namespace FourSlashInterface { this.state.printCompletionListMembers(); } + public printAvailableCodeFixes() { + this.state.printAvailableCodeFixes(); + } + public printBreakpointLocation(pos: number) { this.state.printBreakpointLocation(pos); } diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 29eec3561483d..2c4eef1739dc9 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -191,7 +191,7 @@ namespace Utils { for (const childName in node) { if (childName === "parent" || childName === "nextContainer" || childName === "modifiers" || childName === "externalModuleIndicator" || // for now ignore jsdoc comments - childName === "jsDocComment") { + childName === "jsDocComment" || childName === "checkJsDirective") { continue; } const child = (node)[childName]; @@ -1797,7 +1797,7 @@ namespace Harness { if (currentFileContent === undefined) { currentFileContent = ""; } - else { + else if (currentFileContent !== "") { // End-of-line currentFileContent = currentFileContent + "\n"; } diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts index e7f3274857063..14508640faff6 100644 --- a/src/harness/harnessLanguageService.ts +++ b/src/harness/harnessLanguageService.ts @@ -169,9 +169,9 @@ namespace Harness.LanguageService { } /** - * @param line 0 based index - * @param col 0 based index - */ + * @param line 0 based index + * @param col 0 based index + */ public positionToLineAndCharacter(fileName: string, position: number): ts.LineAndCharacter { const script: ScriptInfo = this.getScriptInfo(fileName); assert.isOk(script); diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json index 1bbdfa71280b4..259dd27b486b3 100644 --- a/src/harness/tsconfig.json +++ b/src/harness/tsconfig.json @@ -1,4 +1,4 @@ -{ +{ "extends": "../tsconfig-base", "compilerOptions": { "removeComments": false, @@ -81,6 +81,7 @@ "../services/codefixes/helpers.ts", "../services/codefixes/importFixes.ts", "../services/codefixes/unusedIdentifierFixes.ts", + "../services/codefixes/disableJsDiagnostics.ts", "harness.ts", "sourceMapRecorder.ts", @@ -95,7 +96,7 @@ "rwcRunner.ts", "test262Runner.ts", "runner.ts", - "../server/protocol.d.ts", + "../server/protocol.ts", "../server/session.ts", "../server/client.ts", "../server/editorServices.ts", @@ -111,6 +112,7 @@ "./unittests/transpile.ts", "./unittests/reuseProgramStructure.ts", "./unittests/cachingInServerLSHost.ts", + "./unittests/checkerPublicRelationships.ts", "./unittests/moduleResolution.ts", "./unittests/tsconfigParsing.ts", "./unittests/commandLineParsing.ts", diff --git a/src/harness/unittests/cachingInServerLSHost.ts b/src/harness/unittests/cachingInServerLSHost.ts index 5ea45d2a5f686..e20288b8cd99a 100644 --- a/src/harness/unittests/cachingInServerLSHost.ts +++ b/src/harness/unittests/cachingInServerLSHost.ts @@ -203,4 +203,4 @@ namespace ts { assert.isTrue(diags.length === 0); }); }); -} \ No newline at end of file +} diff --git a/src/harness/unittests/checkerPublicRelationships.ts b/src/harness/unittests/checkerPublicRelationships.ts new file mode 100644 index 0000000000000..c4b1ef895c6a2 --- /dev/null +++ b/src/harness/unittests/checkerPublicRelationships.ts @@ -0,0 +1,195 @@ +/// +/// + +namespace ts { + describe("Type Checker Public Relationship APIs", () => { + let checker: TypeChecker; + let host: CompilerHost; + let program: Program; + before(() => { + host = Harness.Compiler.createCompilerHost([{ + unitName: "test.ts", + content: ` + type FunctionAlias = Function; + function foo() { + type Function = { myBrand: 42 } & FunctionAlias; + return (() => {}) as any as Function; + } + function foo2(x: T) { + type Function = { myBrand: T } & FunctionAlias; + const ret = (() => {}) as any as Function; + ret.myBrand = x; + return ret; + } + const xs: number[] = [1,2,3]; + ` + }], () => void 0, ScriptTarget.ES3, /*useCaseSensitiveFileNames*/true, "", NewLineKind.CarriageReturnLineFeed); + program = ts.createProgram(["test.ts"], ts.defaultInitCompilerOptions, host); + const diag = ts.getPreEmitDiagnostics(program); + if (diag.length) { + const errors = ts.formatDiagnostics(diag, host); + console.log(errors); + } + checker = program.getTypeChecker(); + }); + + it("can get the any type", () => { + assert(checker.getAnyType().flags & TypeFlags.Any); + }); + + it("can get the string type", () => { + assert(checker.getStringType().flags & TypeFlags.String); + }); + + it("can get the number type", () => { + assert(checker.getNumberType().flags & TypeFlags.Number); + }); + + it("can get the boolean type", () => { + assert(checker.getBooleanType().flags & TypeFlags.Boolean); + }); + + it("can get the void type", () => { + assert(checker.getVoidType().flags & TypeFlags.Void); + }); + + it("can get the undefined type", () => { + assert(checker.getUndefinedType().flags & TypeFlags.Undefined); + }); + + it("can get the null type", () => { + assert(checker.getNullType().flags & TypeFlags.Null); + }); + + it("can get the essymbol type", () => { + assert(checker.getESSymbolType().flags & TypeFlags.ESSymbol); + }); + + it("can get the never type", () => { + assert(checker.getNeverType().flags & TypeFlags.Never); + }); + + it("can get the unknown type", () => { + assert(checker.getUnknownType().flags & TypeFlags.Any); + assert(checker.getUnknownType() === checker.getUnknownType()); + }); + + it("can get the true type", () => { + assert(checker.getTrueType().flags & TypeFlags.BooleanLiteral); + }); + + it("can get the false type", () => { + assert(checker.getFalseType().flags & TypeFlags.BooleanLiteral); + }); + + it("ensures true and false are different types", () => { + assert(checker.getFalseType() !== checker.getTrueType()); + }); + + it("can get string literal types", () => { + assert((checker.getStringLiteralType("foobar") as LiteralType).text === "foobar"); + }); + + it("can get numeber literal types", () => { + assert((checker.getNumberLiteralType("42") as LiteralType).text === "42"); + }); + + it("doesn't choke on exceptional input to literal type getters", () => { + assert.equal((checker.getStringLiteralType("") as LiteralType).text, ""); + assert.throws(() => checker.getStringLiteralType(undefined), Error, "Debug Failure. False expression:"); + /* tslint:disable:no-null-keyword */ + assert.throws(() => checker.getStringLiteralType(null), Error, "Debug Failure. False expression:"); + /* tslint:enable:no-null-keyword */ + let hugeStringLiteral = map(new Array(2 ** 16 - 1), () => "a").join(); + assert.equal((checker.getStringLiteralType(hugeStringLiteral) as LiteralType).text, hugeStringLiteral); + hugeStringLiteral = undefined; + + + assert.throws(() => checker.getNumberLiteralType(undefined), Error, "Debug Failure. False expression:"); + /* tslint:disable:no-null-keyword */ + assert.throws(() => checker.getNumberLiteralType(null), Error, "Debug Failure. False expression:"); + /* tslint:enable:no-null-keyword */ + + const sanityChecks = ["000", "0b0", "0x0", "0.0", "0e-0", "-010", "-0b10", "-0x10", "-0o10", "-10.0", "-1e-1", "NaN", "Infinity", "-Infinity"]; + forEach(sanityChecks, num => { + assert.equal((checker.getNumberLiteralType(num) as LiteralType).text, num, `${num} did not match.`); + }); + + const insanityChecks = [[0, "0"], [0b0, "0"], [-10, "-10"], [NaN, "NaN"], [Infinity, "Infinity"], [-Infinity, "-Infinity"]]; + forEach(insanityChecks, ([num, expected]) => { + assert.equal((checker.getNumberLiteralType(num as any) as LiteralType).text, expected, `${JSON.stringify(num)} should be ${expected}`); + }); + + const instabilityChecks = [{ foo: 42 }, new Date(42), [42], new Number(42), new String("42")]; + forEach(instabilityChecks, (bad) => { + assert.throws(() => checker.getNumberLiteralType(bad as any)); + }); + }); + + it("can look up global types", () => { + assert.equal(checker.lookupGlobalType("Array").symbol.name, "Array", "Array global symbol not named Array"); + const globalFunction = checker.lookupGlobalType("Function"); + const globalAlias = checker.lookupGlobalType("FunctionAlias"); + assert.notEqual(globalFunction, checker.getUnknownType(), "The global function type should not be the unknown type"); + assert.notEqual(globalAlias, checker.getUnknownType(), "The global alias function type should not be the unknown type"); + const globalFunctionLength = globalFunction.getProperty("length"); + const aliasFunctionLength = globalAlias.getProperty("length"); + assert(globalFunctionLength, "Global function length symbol should exist"); + assert(aliasFunctionLength, "Alias function length symbol should exist"); + assert.notEqual(checker.getTypeOfSymbol(globalFunctionLength), checker.getUnknownType(), "The global function's length type should not be unknown"); + assert.notEqual(checker.getTypeOfSymbol(aliasFunctionLength), checker.getUnknownType(), "The alias function's length type should not be unknown"); + assert.equal(checker.getTypeOfSymbol(globalFunctionLength), checker.getTypeOfSymbol(aliasFunctionLength), "Alias and global function length were not identical types"); + assert.equal((checker.getTypeOfSymbol(globalFunctionLength) as IntrinsicType).intrinsicName, (checker.getNumberType() as IntrinsicType).intrinsicName, "Function length was not number type"); + }); + + it("can look up types in a given scope", () => { + assert(program.getSourceFile("test.ts"), "Test file not found"); + const functionBody = forEachChild(program.getSourceFile("test.ts"), node => node.kind === SyntaxKind.FunctionDeclaration ? (node as FunctionDeclaration) : undefined).body; + assert(functionBody, "Function body missing"); + const innerFunction = checker.lookupTypeAt("Function", functionBody.statements[functionBody.statements.length - 1]); + assert(innerFunction, "Inner function type missing"); + assert.notEqual(innerFunction, checker.getUnknownType(), "Inner function type should not be unknown"); + assert.notEqual(checker.lookupGlobalType("Function"), innerFunction, "Inner function type should be different than global"); + const brandNameType = checker.getTypeOfSymbol(innerFunction.getProperty("myBrand")); + assert.notEqual(brandNameType, checker.getUnknownType(), "Brand type on inner function should not be unknown"); + assert.equal(brandNameType, checker.getNumberLiteralType("42"), "Brand type should be 42"); + + let skipped = false; + const functionBody2 = forEachChild(program.getSourceFile("test.ts"), node => node.kind === SyntaxKind.FunctionDeclaration ? skipped ? (node as FunctionDeclaration) : (skipped = true, undefined) : undefined).body; + assert(functionBody2, "Function body missing"); + const innerFunction2 = checker.lookupTypeAt("Function", functionBody2.statements[functionBody2.statements.length - 1]); + assert(innerFunction2, "Inner function type missing"); + assert.notEqual(innerFunction2, checker.getUnknownType(), "Inner function type should not be unknown"); + assert.notEqual(checker.lookupGlobalType("Function"), innerFunction2, "Inner function type should be different than global"); + const brandNameType2 = checker.getTypeOfSymbol(innerFunction2.getProperty("myBrand")); + assert.notEqual(brandNameType2, checker.getUnknownType(), "Brand type on inner function should not be unknown"); + const functionType = checker.lookupGlobalValueType("foo2"); + assert.notEqual(functionType, checker.getUnknownType(), "foo2 function type should not be unknown"); + assert(brandNameType2.flags & TypeFlags.TypeParameter, "Brand should be a type parameter"); + assert.equal(brandNameType2, checker.lookupGlobalValueType("foo2").getCallSignatures()[0].getTypeParameters()[0], "Brand type should be a type parameter"); + }); + + it("can compare types using all the builtin relationships", () => { + assert(checker.isSubtypeOf(checker.getNumberType(), checker.getAnyType()), "Any should be a subtype of number"); + assert.isFalse(checker.isSubtypeOf(checker.getAnyType(), checker.getNumberType()), "Number should not be a subtype of any"); + + assert(checker.isAssignableTo(checker.getAnyType(), checker.getNumberType()), "Any should be assignable to number"); + assert(checker.isAssignableTo(checker.getFalseType(), checker.getBooleanType()), "False should be assignable to boolean"); + + assert(checker.isComparableTo(checker.getBooleanType(), checker.getFalseType()), "False and boolean are comparable"); + assert(checker.isComparableTo(checker.getFalseType(), checker.getBooleanType()), "Boolean and false are comparable"); + + const variableType = checker.lookupGlobalValueType("xs"); + const globalArrayType = checker.lookupGlobalType("Array"); + assert.notEqual(variableType, checker.getUnknownType(), "xs type should not be unknown"); + assert.notEqual(globalArrayType, checker.getUnknownType(), "Global array type should not be unknown"); + assert(checker.isInstantiationOf(checker.lookupGlobalValueType("xs") as GenericType, checker.lookupGlobalType("Array") as GenericType)); + }); + + after(() => { + checker = undefined; + host = undefined; + program = undefined; + }); + }); +} \ No newline at end of file diff --git a/src/harness/unittests/convertToBase64.ts b/src/harness/unittests/convertToBase64.ts index 09e38bdf674b1..975d21a38384b 100644 --- a/src/harness/unittests/convertToBase64.ts +++ b/src/harness/unittests/convertToBase64.ts @@ -22,7 +22,7 @@ namespace ts { }); it("Converts simple code snippet correctly", () => { - runTest(`/// + runTest(`/// var x: string = "string"; console.log(x);`); }); diff --git a/src/harness/unittests/moduleResolution.ts b/src/harness/unittests/moduleResolution.ts index aa30f1e01e2bd..5ea652573b6ca 100644 --- a/src/harness/unittests/moduleResolution.ts +++ b/src/harness/unittests/moduleResolution.ts @@ -151,7 +151,7 @@ namespace ts { it("module name as directory - handle invalid 'typings'", () => { testTypingsIgnored(["a", "b"]); testTypingsIgnored({ "a": "b" }); - testTypingsIgnored(true); + testTypingsIgnored(/*typings*/true); /* tslint:disable no-null-keyword */ testTypingsIgnored(null); /* tslint:enable no-null-keyword */ diff --git a/src/harness/unittests/printer.ts b/src/harness/unittests/printer.ts index e5167b592c259..894ffcf0ea2d2 100644 --- a/src/harness/unittests/printer.ts +++ b/src/harness/unittests/printer.ts @@ -52,6 +52,9 @@ namespace ts { printsCorrectly("default", {}, printer => printer.printFile(sourceFile)); printsCorrectly("removeComments", { removeComments: true }, printer => printer.printFile(sourceFile)); + + // github #14948 + printsCorrectly("templateLiteral", {}, printer => printer.printFile(createSourceFile("source.ts", "let greeting = `Hi ${name}, how are you?`;", ScriptTarget.ES2017))); }); describe("printBundle", () => { diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts index d3ea153e235cb..9a38de7da1089 100644 --- a/src/harness/unittests/session.ts +++ b/src/harness/unittests/session.ts @@ -326,7 +326,7 @@ namespace ts.server { send(msg: protocol.Message) { this.lastSent = msg; } - }; + } it("can override methods such as send", () => { const session = new TestSession(); @@ -367,7 +367,7 @@ namespace ts.server { assert(this.projectService); expect(this.projectService).to.be.instanceOf(ProjectService); } - }; + } new ServiceSession(); }); }); @@ -462,7 +462,7 @@ namespace ts.server { }); this.callbacks[this.seq] = callback; } - }; + } it("can be constructed and respond to commands", (done) => { const cli = new InProcClient(); diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 356a7a8962df9..53fcff30ad989 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -174,13 +174,13 @@ namespace ts.projectSystem { request.type = "request"; return this.executeCommand(request); } - }; + } - export function createSession(host: server.ServerHost, typingsInstaller?: server.ITypingsInstaller, projectServiceEventHandler?: server.ProjectServiceEventHandler, cancellationToken?: server.ServerCancellationToken) { + export function createSession(host: server.ServerHost, typingsInstaller?: server.ITypingsInstaller, projectServiceEventHandler?: server.ProjectServiceEventHandler, cancellationToken?: server.ServerCancellationToken, throttleWaitMilliseconds?: number) { if (typingsInstaller === undefined) { typingsInstaller = new TestTypingsInstaller("/a/data/", /*throttleLimit*/5, host); } - return new TestSession(host, cancellationToken || server.nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ projectServiceEventHandler !== undefined, projectServiceEventHandler); + return new TestSession(host, cancellationToken || server.nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ projectServiceEventHandler !== undefined, projectServiceEventHandler, throttleWaitMilliseconds); } export interface CreateProjectServiceParameters { @@ -381,7 +381,7 @@ namespace ts.projectSystem { fileExists(s: string) { const path = this.toPath(s); return this.fs.contains(path) && isFile(this.fs.get(path)); - }; + } getFileSize(s: string) { const path = this.toPath(s); @@ -476,11 +476,11 @@ namespace ts.projectSystem { // TOOD: record and invoke callbacks to simulate timer events setTimeout(callback: TimeOutCallback, _time: number, ...args: any[]) { return this.timeoutCallbacks.register(callback, args); - }; + } clearTimeout(timeoutId: any): void { this.timeoutCallbacks.unregister(timeoutId); - }; + } checkTimeoutQueueLength(expected: number) { const callbacksCount = this.timeoutCallbacks.count(); @@ -501,7 +501,7 @@ namespace ts.projectSystem { clearImmediate(timeoutId: any): void { this.immediateCallbacks.unregister(timeoutId); - }; + } createDirectory(directoryName: string): void { this.createFileOrFolder({ path: directoryName }); @@ -547,6 +547,49 @@ namespace ts.projectSystem { readonly getEnvironmentVariable = notImplemented; } + /** + * Test server cancellation token used to mock host token cancellation requests. + * The cancelAfterRequest constructor param specifies how many isCancellationRequested() calls + * should be made before canceling the token. The id of the request to cancel should be set with + * setRequestToCancel(); + */ + export class TestServerCancellationToken implements server.ServerCancellationToken { + private currentId = -1; + private requestToCancel = -1; + private isCancellationRequestedCount = 0; + + constructor(private cancelAfterRequest = 0) { + } + + setRequest(requestId: number) { + this.currentId = requestId; + } + + setRequestToCancel(requestId: number) { + this.resetToken(); + this.requestToCancel = requestId; + } + + resetRequest(requestId: number) { + assert.equal(requestId, this.currentId, "unexpected request id in cancellation"); + this.currentId = undefined; + } + + isCancellationRequested() { + this.isCancellationRequestedCount++; + // If the request id is the request to cancel and isCancellationRequestedCount + // has been met then cancel the request. Ex: cancel the request if it is a + // nav bar request & isCancellationRequested() has already been called three times. + return this.requestToCancel === this.currentId && this.isCancellationRequestedCount >= this.cancelAfterRequest; + } + + resetToken() { + this.currentId = -1; + this.isCancellationRequestedCount = 0; + this.requestToCancel = -1; + } + } + export function makeSessionRequest(command: string, args: T) { const newRequest: protocol.Request = { seq: 0, @@ -764,7 +807,7 @@ namespace ts.projectSystem { path: "/c/app.ts", content: "let x = 1" }; - const makeProject = (f: FileOrFolder) => ({ projectFileName: f.path + ".csproj", rootFiles: [toExternalFile(f.path)], options: {} }); + const makeProject = (f: FileOrFolder) => ({ projectFileName: f.path + ".csproj", rootFiles: [toExternalFile(f.path)], options: {} }); const p1 = makeProject(f1); const p2 = makeProject(f2); const p3 = makeProject(f3); @@ -3384,6 +3427,7 @@ namespace ts.projectSystem { }, resetRequest: noop }; + const session = createSession(host, /*typingsInstaller*/ undefined, /*projectServiceEventHandler*/ undefined, cancellationToken); expectedRequestId = session.getNextSeq(); @@ -3422,22 +3466,7 @@ namespace ts.projectSystem { }) }; - let requestToCancel = -1; - const cancellationToken: server.ServerCancellationToken = (function(){ - let currentId: number; - return { - setRequest(requestId) { - currentId = requestId; - }, - resetRequest(requestId) { - assert.equal(requestId, currentId, "unexpected request id in cancellation"); - currentId = undefined; - }, - isCancellationRequested() { - return requestToCancel === currentId; - } - }; - })(); + const cancellationToken = new TestServerCancellationToken(); const host = createServerHost([f1, config]); const session = createSession(host, /*typingsInstaller*/ undefined, () => {}, cancellationToken); { @@ -3472,13 +3501,13 @@ namespace ts.projectSystem { host.clearOutput(); // cancel previously issued Geterr - requestToCancel = getErrId; + cancellationToken.setRequestToCancel(getErrId); host.runQueuedTimeoutCallbacks(); assert.equal(host.getOutput().length, 1, "expect 1 message"); verifyRequestCompleted(getErrId, 0); - requestToCancel = -1; + cancellationToken.resetToken(); } { const getErrId = session.getNextSeq(); @@ -3495,12 +3524,12 @@ namespace ts.projectSystem { assert.equal(e1.event, "syntaxDiag"); host.clearOutput(); - requestToCancel = getErrId; + cancellationToken.setRequestToCancel(getErrId); host.runQueuedImmediateCallbacks(); assert.equal(host.getOutput().length, 1, "expect 1 message"); verifyRequestCompleted(getErrId, 0); - requestToCancel = -1; + cancellationToken.resetToken(); } { const getErrId = session.getNextSeq(); @@ -3523,7 +3552,7 @@ namespace ts.projectSystem { assert.equal(e2.event, "semanticDiag"); verifyRequestCompleted(getErrId, 1); - requestToCancel = -1; + cancellationToken.resetToken(); } { const getErr1 = session.getNextSeq(); @@ -3558,6 +3587,68 @@ namespace ts.projectSystem { return JSON.parse(server.extractMessage(host.getOutput()[n])); } }); + it("Lower priority tasks are cancellable", () => { + const f1 = { + path: "/a/app.ts", + content: `{ let x = 1; } var foo = "foo"; var bar = "bar"; var fooBar = "fooBar";` + }; + const config = { + path: "/a/tsconfig.json", + content: JSON.stringify({ + compilerOptions: {} + }) + }; + const cancellationToken = new TestServerCancellationToken(/*cancelAfterRequest*/ 3); + const host = createServerHost([f1, config]); + const session = createSession(host, /*typingsInstaller*/ undefined, () => { }, cancellationToken, /*throttleWaitMilliseconds*/ 0); + { + session.executeCommandSeq({ + command: "open", + arguments: { file: f1.path } + }); + + // send navbar request (normal priority) + session.executeCommandSeq({ + command: "navbar", + arguments: { file: f1.path } + }); + + // ensure the nav bar request can be canceled + verifyExecuteCommandSeqIsCancellable({ + command: "navbar", + arguments: { file: f1.path } + }); + + // send outlining spans request (normal priority) + session.executeCommandSeq({ + command: "outliningSpans", + arguments: { file: f1.path } + }); + + // ensure the outlining spans request can be canceled + verifyExecuteCommandSeqIsCancellable({ + command: "outliningSpans", + arguments: { file: f1.path } + }); + } + + function verifyExecuteCommandSeqIsCancellable(request: Partial) { + // Set the next request to be cancellable + // The cancellation token will cancel the request the third time + // isCancellationRequested() is called. + cancellationToken.setRequestToCancel(session.getNextSeq()); + let operationCanceledExceptionThrown = false; + + try { + session.executeCommandSeq(request); + } + catch (e) { + assert(e instanceof OperationCanceledException); + operationCanceledExceptionThrown = true; + } + assert(operationCanceledExceptionThrown, "Operation Canceled Exception not thrown for request: " + JSON.stringify(request)); + } + }); }); describe("occurence highlight on string", () => { diff --git a/src/harness/unittests/typingsInstaller.ts b/src/harness/unittests/typingsInstaller.ts index 12e62aaa7b9ab..d6f8a2d01fcee 100644 --- a/src/harness/unittests/typingsInstaller.ts +++ b/src/harness/unittests/typingsInstaller.ts @@ -692,7 +692,54 @@ namespace ts.projectSystem { checkProjectActualFiles(p, [app.path, jqueryDTS.path]); }); - it("configured projects discover from bower.josn", () => { + it("configured projects discover from bower_components", () => { + const app = { + path: "/app.js", + content: "" + }; + const jsconfig = { + path: "/jsconfig.json", + content: JSON.stringify({}) + }; + const jquery = { + path: "/bower_components/jquery/index.js", + content: "" + }; + const jqueryPackage = { + path: "/bower_components/jquery/package.json", + content: JSON.stringify({ name: "jquery" }) + }; + const jqueryDTS = { + path: "/tmp/node_modules/@types/jquery/index.d.ts", + content: "" + }; + const host = createServerHost([app, jsconfig, jquery, jqueryPackage]); + const installer = new (class extends Installer { + constructor() { + super(host, { globalTypingsCacheLocation: "/tmp", typesRegistry: createTypesRegistry("jquery") }); + } + installWorker(_requestId: number, _args: string[], _cwd: string, cb: server.typingsInstaller.RequestCompletedAction) { + const installedTypings = ["@types/jquery"]; + const typingFiles = [jqueryDTS]; + executeCommand(this, host, installedTypings, typingFiles, cb); + } + })(); + + const projectService = createProjectService(host, { useSingleInferredProject: true, typingsInstaller: installer }); + projectService.openClientFile(app.path); + + checkNumberOfProjects(projectService, { configuredProjects: 1 }); + const p = projectService.configuredProjects[0]; + checkProjectActualFiles(p, [app.path]); + checkWatchedFiles(host, [jsconfig.path, "/bower_components", "/node_modules"]); + + installer.installAll(/*expectedCount*/ 1); + + checkNumberOfProjects(projectService, { configuredProjects: 1 }); + checkProjectActualFiles(p, [app.path, jqueryDTS.path]); + }); + + it("configured projects discover from bower.json", () => { const app = { path: "/app.js", content: "" @@ -975,7 +1022,7 @@ namespace ts.projectSystem { } }); - it("should use cached locaitons", () => { + it("should use cached locations", () => { const f = { path: "/a/b/app.js", content: "" diff --git a/src/lib/dom.iterable.d.ts b/src/lib/dom.iterable.d.ts index 9a04b723ac22b..b5e0404c17bdd 100644 --- a/src/lib/dom.iterable.d.ts +++ b/src/lib/dom.iterable.d.ts @@ -4,25 +4,42 @@ interface DOMTokenList { [Symbol.iterator](): IterableIterator; } +interface FormData { + /** + * Returns an array of key, value pairs for every entry in the list + */ + entries(): IterableIterator<[string, string | File]>; + /** + * Returns a list of keys in the list + */ + keys(): IterableIterator; + /** + * Returns a list of values in the list + */ + values(): IterableIterator; + + [Symbol.iterator](): IterableIterator; +} + interface NodeList { /** - * Returns an array of key, value pairs for every entry in the list - */ + * Returns an array of key, value pairs for every entry in the list + */ entries(): IterableIterator<[number, Node]>; /** - * Performs the specified action for each node in an list. - * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list. - * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. - */ + * Performs the specified action for each node in an list. + * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ forEach(callbackfn: (value: Node, index: number, listObj: NodeList) => void, thisArg?: any): void; /** - * Returns an list of keys in the list - */ + * Returns an list of keys in the list + */ keys(): IterableIterator; /** - * Returns an list of values in the list - */ + * Returns an list of values in the list + */ values(): IterableIterator; @@ -32,23 +49,23 @@ interface NodeList { interface NodeListOf { /** - * Returns an array of key, value pairs for every entry in the list - */ + * Returns an array of key, value pairs for every entry in the list + */ entries(): IterableIterator<[number, TNode]>; /** - * Performs the specified action for each node in an list. - * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list. - * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. - */ + * Performs the specified action for each node in an list. + * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ forEach(callbackfn: (value: TNode, index: number, listObj: NodeListOf) => void, thisArg?: any): void; /** - * Returns an list of keys in the list - */ + * Returns an list of keys in the list + */ keys(): IterableIterator; /** - * Returns an list of values in the list - */ + * Returns an list of values in the list + */ values(): IterableIterator; [Symbol.iterator](): IterableIterator; diff --git a/src/lib/es2015.core.d.ts b/src/lib/es2015.core.d.ts index 2e56221fe9aa6..341fd80872cad 100644 --- a/src/lib/es2015.core.d.ts +++ b/src/lib/es2015.core.d.ts @@ -2,75 +2,75 @@ declare type PropertyKey = string | number | symbol; interface Array { /** - * Returns the value of the first element in the array where predicate is true, and undefined - * otherwise. - * @param predicate find calls predicate once for each element of the array, in ascending - * order, until it finds one where predicate returns true. If such an element is found, find - * immediately returns that element value. Otherwise, find returns undefined. - * @param thisArg If provided, it will be used as the this value for each invocation of - * predicate. If it is not provided, undefined is used instead. - */ + * Returns the value of the first element in the array where predicate is true, and undefined + * otherwise. + * @param predicate find calls predicate once for each element of the array, in ascending + * order, until it finds one where predicate returns true. If such an element is found, find + * immediately returns that element value. Otherwise, find returns undefined. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ find(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean): T | undefined; find(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean, thisArg: undefined): T | undefined; find(predicate: (this: Z, value: T, index: number, obj: Array) => boolean, thisArg: Z): T | undefined; /** - * Returns the index of the first element in the array where predicate is true, and -1 - * otherwise. - * @param predicate find calls predicate once for each element of the array, in ascending - * order, until it finds one where predicate returns true. If such an element is found, - * findIndex immediately returns that element index. Otherwise, findIndex returns -1. - * @param thisArg If provided, it will be used as the this value for each invocation of - * predicate. If it is not provided, undefined is used instead. - */ + * Returns the index of the first element in the array where predicate is true, and -1 + * otherwise. + * @param predicate find calls predicate once for each element of the array, in ascending + * order, until it finds one where predicate returns true. If such an element is found, + * findIndex immediately returns that element index. Otherwise, findIndex returns -1. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean): number; findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: T, index: number, obj: Array) => boolean, thisArg: Z): number; /** - * Returns the this object after filling the section identified by start and end with value - * @param value value to fill array section with - * @param start index to start filling the array at. If start is negative, it is treated as - * length+start where length is the length of the array. - * @param end index to stop filling the array at. If end is negative, it is treated as - * length+end. - */ + * Returns the this object after filling the section identified by start and end with value + * @param value value to fill array section with + * @param start index to start filling the array at. If start is negative, it is treated as + * length+start where length is the length of the array. + * @param end index to stop filling the array at. If end is negative, it is treated as + * length+end. + */ fill(value: T, start?: number, end?: number): this; /** - * Returns the this object after copying a section of the array identified by start and end - * to the same array starting at position target - * @param target If target is negative, it is treated as length+target where length is the - * length of the array. - * @param start If start is negative, it is treated as length+start. If end is negative, it - * is treated as length+end. - * @param end If not specified, length of the this object is used as its default value. - */ + * Returns the this object after copying a section of the array identified by start and end + * to the same array starting at position target + * @param target If target is negative, it is treated as length+target where length is the + * length of the array. + * @param start If start is negative, it is treated as length+start. If end is negative, it + * is treated as length+end. + * @param end If not specified, length of the this object is used as its default value. + */ copyWithin(target: number, start: number, end?: number): this; } interface ArrayConstructor { /** - * Creates an array from an array-like object. - * @param arrayLike An array-like object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like object. + * @param arrayLike An array-like object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): Array; from(arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): Array; /** - * Creates an array from an array-like object. - * @param arrayLike An array-like object to convert to an array. - */ + * Creates an array from an array-like object. + * @param arrayLike An array-like object to convert to an array. + */ from(arrayLike: ArrayLike): Array; /** - * Returns a new array from a set of elements. - * @param items A set of elements to include in the new array object. - */ + * Returns a new array from a set of elements. + * @param items A set of elements to include in the new array object. + */ of(...items: T[]): Array; } @@ -80,332 +80,332 @@ interface DateConstructor { interface Function { /** - * Returns the name of the function. Function names are read-only and can not be changed. - */ + * Returns the name of the function. Function names are read-only and can not be changed. + */ readonly name: string; } interface Math { /** - * Returns the number of leading zero bits in the 32-bit binary representation of a number. - * @param x A numeric expression. - */ + * Returns the number of leading zero bits in the 32-bit binary representation of a number. + * @param x A numeric expression. + */ clz32(x: number): number; /** - * Returns the result of 32-bit multiplication of two numbers. - * @param x First number - * @param y Second number - */ + * Returns the result of 32-bit multiplication of two numbers. + * @param x First number + * @param y Second number + */ imul(x: number, y: number): number; /** - * Returns the sign of the x, indicating whether x is positive, negative or zero. - * @param x The numeric expression to test - */ + * Returns the sign of the x, indicating whether x is positive, negative or zero. + * @param x The numeric expression to test + */ sign(x: number): number; /** - * Returns the base 10 logarithm of a number. - * @param x A numeric expression. - */ + * Returns the base 10 logarithm of a number. + * @param x A numeric expression. + */ log10(x: number): number; /** - * Returns the base 2 logarithm of a number. - * @param x A numeric expression. - */ + * Returns the base 2 logarithm of a number. + * @param x A numeric expression. + */ log2(x: number): number; /** - * Returns the natural logarithm of 1 + x. - * @param x A numeric expression. - */ + * Returns the natural logarithm of 1 + x. + * @param x A numeric expression. + */ log1p(x: number): number; /** - * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of - * the natural logarithms). - * @param x A numeric expression. - */ + * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of + * the natural logarithms). + * @param x A numeric expression. + */ expm1(x: number): number; /** - * Returns the hyperbolic cosine of a number. - * @param x A numeric expression that contains an angle measured in radians. - */ + * Returns the hyperbolic cosine of a number. + * @param x A numeric expression that contains an angle measured in radians. + */ cosh(x: number): number; /** - * Returns the hyperbolic sine of a number. - * @param x A numeric expression that contains an angle measured in radians. - */ + * Returns the hyperbolic sine of a number. + * @param x A numeric expression that contains an angle measured in radians. + */ sinh(x: number): number; /** - * Returns the hyperbolic tangent of a number. - * @param x A numeric expression that contains an angle measured in radians. - */ + * Returns the hyperbolic tangent of a number. + * @param x A numeric expression that contains an angle measured in radians. + */ tanh(x: number): number; /** - * Returns the inverse hyperbolic cosine of a number. - * @param x A numeric expression that contains an angle measured in radians. - */ + * Returns the inverse hyperbolic cosine of a number. + * @param x A numeric expression that contains an angle measured in radians. + */ acosh(x: number): number; /** - * Returns the inverse hyperbolic sine of a number. - * @param x A numeric expression that contains an angle measured in radians. - */ + * Returns the inverse hyperbolic sine of a number. + * @param x A numeric expression that contains an angle measured in radians. + */ asinh(x: number): number; /** - * Returns the inverse hyperbolic tangent of a number. - * @param x A numeric expression that contains an angle measured in radians. - */ + * Returns the inverse hyperbolic tangent of a number. + * @param x A numeric expression that contains an angle measured in radians. + */ atanh(x: number): number; /** - * Returns the square root of the sum of squares of its arguments. - * @param values Values to compute the square root for. - * If no arguments are passed, the result is +0. - * If there is only one argument, the result is the absolute value. - * If any argument is +Infinity or -Infinity, the result is +Infinity. - * If any argument is NaN, the result is NaN. - * If all arguments are either +0 or −0, the result is +0. - */ + * Returns the square root of the sum of squares of its arguments. + * @param values Values to compute the square root for. + * If no arguments are passed, the result is +0. + * If there is only one argument, the result is the absolute value. + * If any argument is +Infinity or -Infinity, the result is +Infinity. + * If any argument is NaN, the result is NaN. + * If all arguments are either +0 or −0, the result is +0. + */ hypot(...values: number[] ): number; /** - * Returns the integral part of the a numeric expression, x, removing any fractional digits. - * If x is already an integer, the result is x. - * @param x A numeric expression. - */ + * Returns the integral part of the a numeric expression, x, removing any fractional digits. + * If x is already an integer, the result is x. + * @param x A numeric expression. + */ trunc(x: number): number; /** - * Returns the nearest single precision float representation of a number. - * @param x A numeric expression. - */ + * Returns the nearest single precision float representation of a number. + * @param x A numeric expression. + */ fround(x: number): number; /** - * Returns an implementation-dependent approximation to the cube root of number. - * @param x A numeric expression. - */ + * Returns an implementation-dependent approximation to the cube root of number. + * @param x A numeric expression. + */ cbrt(x: number): number; } interface NumberConstructor { /** - * The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1 - * that is representable as a Number value, which is approximately: - * 2.2204460492503130808472633361816 x 10‍−‍16. - */ + * The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1 + * that is representable as a Number value, which is approximately: + * 2.2204460492503130808472633361816 x 10‍−‍16. + */ readonly EPSILON: number; /** - * Returns true if passed value is finite. - * Unlike the global isFinite, Number.isFinite doesn't forcibly convert the parameter to a - * number. Only finite values of the type number, result in true. - * @param number A numeric value. - */ + * Returns true if passed value is finite. + * Unlike the global isFinite, Number.isFinite doesn't forcibly convert the parameter to a + * number. Only finite values of the type number, result in true. + * @param number A numeric value. + */ isFinite(number: number): boolean; /** - * Returns true if the value passed is an integer, false otherwise. - * @param number A numeric value. - */ + * Returns true if the value passed is an integer, false otherwise. + * @param number A numeric value. + */ isInteger(number: number): boolean; /** - * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a - * number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter - * to a number. Only values of the type number, that are also NaN, result in true. - * @param number A numeric value. - */ + * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a + * number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter + * to a number. Only values of the type number, that are also NaN, result in true. + * @param number A numeric value. + */ isNaN(number: number): boolean; /** - * Returns true if the value passed is a safe integer. - * @param number A numeric value. - */ + * Returns true if the value passed is a safe integer. + * @param number A numeric value. + */ isSafeInteger(number: number): boolean; /** - * The value of the largest integer n such that n and n + 1 are both exactly representable as - * a Number value. - * The value of Number.MAX_SAFE_INTEGER is 9007199254740991 2^53 − 1. - */ + * The value of the largest integer n such that n and n + 1 are both exactly representable as + * a Number value. + * The value of Number.MAX_SAFE_INTEGER is 9007199254740991 2^53 − 1. + */ readonly MAX_SAFE_INTEGER: number; /** - * The value of the smallest integer n such that n and n − 1 are both exactly representable as - * a Number value. - * The value of Number.MIN_SAFE_INTEGER is −9007199254740991 (−(2^53 − 1)). - */ + * The value of the smallest integer n such that n and n − 1 are both exactly representable as + * a Number value. + * The value of Number.MIN_SAFE_INTEGER is −9007199254740991 (−(2^53 − 1)). + */ readonly MIN_SAFE_INTEGER: number; /** - * Converts a string to a floating-point number. - * @param string A string that contains a floating-point number. - */ + * Converts a string to a floating-point number. + * @param string A string that contains a floating-point number. + */ parseFloat(string: string): number; /** - * Converts A string to an integer. - * @param s A string to convert into a number. - * @param radix A value between 2 and 36 that specifies the base of the number in numString. - * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal. - * All other strings are considered decimal. - */ + * Converts A string to an integer. + * @param s A string to convert into a number. + * @param radix A value between 2 and 36 that specifies the base of the number in numString. + * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal. + * All other strings are considered decimal. + */ parseInt(string: string, radix?: number): number; } interface Object { /** - * Determines whether an object has a property with the specified name. - * @param v A property name. - */ + * Determines whether an object has a property with the specified name. + * @param v A property name. + */ hasOwnProperty(v: PropertyKey): boolean; /** - * Determines whether a specified property is enumerable. - * @param v A property name. - */ + * Determines whether a specified property is enumerable. + * @param v A property name. + */ propertyIsEnumerable(v: PropertyKey): boolean; } interface ObjectConstructor { /** - * Copy the values of all of the enumerable own properties from one or more source objects to a - * target object. Returns the target object. - * @param target The target object to copy to. - * @param source The source object from which to copy properties. - */ + * Copy the values of all of the enumerable own properties from one or more source objects to a + * target object. Returns the target object. + * @param target The target object to copy to. + * @param source The source object from which to copy properties. + */ assign(target: T, source: U): T & U; /** - * Copy the values of all of the enumerable own properties from one or more source objects to a - * target object. Returns the target object. - * @param target The target object to copy to. - * @param source1 The first source object from which to copy properties. - * @param source2 The second source object from which to copy properties. - */ + * Copy the values of all of the enumerable own properties from one or more source objects to a + * target object. Returns the target object. + * @param target The target object to copy to. + * @param source1 The first source object from which to copy properties. + * @param source2 The second source object from which to copy properties. + */ assign(target: T, source1: U, source2: V): T & U & V; /** - * Copy the values of all of the enumerable own properties from one or more source objects to a - * target object. Returns the target object. - * @param target The target object to copy to. - * @param source1 The first source object from which to copy properties. - * @param source2 The second source object from which to copy properties. - * @param source3 The third source object from which to copy properties. - */ + * Copy the values of all of the enumerable own properties from one or more source objects to a + * target object. Returns the target object. + * @param target The target object to copy to. + * @param source1 The first source object from which to copy properties. + * @param source2 The second source object from which to copy properties. + * @param source3 The third source object from which to copy properties. + */ assign(target: T, source1: U, source2: V, source3: W): T & U & V & W; /** - * Copy the values of all of the enumerable own properties from one or more source objects to a - * target object. Returns the target object. - * @param target The target object to copy to. - * @param sources One or more source objects from which to copy properties - */ + * Copy the values of all of the enumerable own properties from one or more source objects to a + * target object. Returns the target object. + * @param target The target object to copy to. + * @param sources One or more source objects from which to copy properties + */ assign(target: any, ...sources: any[]): any; /** - * Returns an array of all symbol properties found directly on object o. - * @param o Object to retrieve the symbols from. - */ + * Returns an array of all symbol properties found directly on object o. + * @param o Object to retrieve the symbols from. + */ getOwnPropertySymbols(o: any): symbol[]; /** - * Returns true if the values are the same value, false otherwise. - * @param value1 The first value. - * @param value2 The second value. - */ + * Returns true if the values are the same value, false otherwise. + * @param value1 The first value. + * @param value2 The second value. + */ is(value1: any, value2: any): boolean; /** - * Sets the prototype of a specified object o to object proto or null. Returns the object o. - * @param o The object to change its prototype. - * @param proto The value of the new prototype or null. - */ + * Sets the prototype of a specified object o to object proto or null. Returns the object o. + * @param o The object to change its prototype. + * @param proto The value of the new prototype or null. + */ setPrototypeOf(o: any, proto: object | null): any; /** - * Gets the own property descriptor of the specified object. - * An own property descriptor is one that is defined directly on the object and is not - * inherited from the object's prototype. - * @param o Object that contains the property. - * @param p Name of the property. - */ + * Gets the own property descriptor of the specified object. + * An own property descriptor is one that is defined directly on the object and is not + * inherited from the object's prototype. + * @param o Object that contains the property. + * @param p Name of the property. + */ getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor; /** - * Adds a property to an object, or modifies attributes of an existing property. - * @param o Object on which to add or modify the property. This can be a native JavaScript - * object (that is, a user-defined object or a built in object) or a DOM object. - * @param p The property name. - * @param attributes Descriptor for the property. It can be for a data property or an accessor - * property. - */ + * Adds a property to an object, or modifies attributes of an existing property. + * @param o Object on which to add or modify the property. This can be a native JavaScript + * object (that is, a user-defined object or a built in object) or a DOM object. + * @param p The property name. + * @param attributes Descriptor for the property. It can be for a data property or an accessor + * property. + */ defineProperty(o: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): any; } interface ReadonlyArray { - /** - * Returns the value of the first element in the array where predicate is true, and undefined - * otherwise. - * @param predicate find calls predicate once for each element of the array, in ascending - * order, until it finds one where predicate returns true. If such an element is found, find - * immediately returns that element value. Otherwise, find returns undefined. - * @param thisArg If provided, it will be used as the this value for each invocation of - * predicate. If it is not provided, undefined is used instead. - */ - find(predicate: (this: undefined, value: T, index: number, obj: ReadonlyArray) => boolean): T | undefined; - find(predicate: (this: undefined, value: T, index: number, obj: ReadonlyArray) => boolean, thisArg: undefined): T | undefined; - find(predicate: (this: Z, value: T, index: number, obj: ReadonlyArray) => boolean, thisArg: Z): T | undefined; - - /** - * Returns the index of the first element in the array where predicate is true, and -1 - * otherwise. - * @param predicate find calls predicate once for each element of the array, in ascending - * order, until it finds one where predicate returns true. If such an element is found, - * findIndex immediately returns that element index. Otherwise, findIndex returns -1. - * @param thisArg If provided, it will be used as the this value for each invocation of - * predicate. If it is not provided, undefined is used instead. - */ - findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean, thisArg: undefined): number; - findIndex(predicate: (this: Z, value: T, index: number, obj: Array) => boolean, thisArg: Z): number; + /** + * Returns the value of the first element in the array where predicate is true, and undefined + * otherwise. + * @param predicate find calls predicate once for each element of the array, in ascending + * order, until it finds one where predicate returns true. If such an element is found, find + * immediately returns that element value. Otherwise, find returns undefined. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ + find(predicate: (this: undefined, value: T, index: number, obj: ReadonlyArray) => boolean): T | undefined; + find(predicate: (this: undefined, value: T, index: number, obj: ReadonlyArray) => boolean, thisArg: undefined): T | undefined; + find(predicate: (this: Z, value: T, index: number, obj: ReadonlyArray) => boolean, thisArg: Z): T | undefined; + + /** + * Returns the index of the first element in the array where predicate is true, and -1 + * otherwise. + * @param predicate find calls predicate once for each element of the array, in ascending + * order, until it finds one where predicate returns true. If such an element is found, + * findIndex immediately returns that element index. Otherwise, findIndex returns -1. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ + findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: Z, value: T, index: number, obj: Array) => boolean, thisArg: Z): number; } interface RegExp { /** - * Returns a string indicating the flags of the regular expression in question. This field is read-only. - * The characters in this string are sequenced and concatenated in the following order: - * - * - "g" for global - * - "i" for ignoreCase - * - "m" for multiline - * - "u" for unicode - * - "y" for sticky - * - * If no flags are set, the value is the empty string. - */ + * Returns a string indicating the flags of the regular expression in question. This field is read-only. + * The characters in this string are sequenced and concatenated in the following order: + * + * - "g" for global + * - "i" for ignoreCase + * - "m" for multiline + * - "u" for unicode + * - "y" for sticky + * + * If no flags are set, the value is the empty string. + */ readonly flags: string; /** - * Returns a Boolean value indicating the state of the sticky flag (y) used with a regular - * expression. Default is false. Read-only. - */ + * Returns a Boolean value indicating the state of the sticky flag (y) used with a regular + * expression. Default is false. Read-only. + */ readonly sticky: boolean; /** - * Returns a Boolean value indicating the state of the Unicode flag (u) used with a regular - * expression. Default is false. Read-only. - */ + * Returns a Boolean value indicating the state of the Unicode flag (u) used with a regular + * expression. Default is false. Read-only. + */ readonly unicode: boolean; } @@ -416,64 +416,64 @@ interface RegExpConstructor { interface String { /** - * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point - * value of the UTF-16 encoded code point starting at the string element at position pos in - * the String resulting from converting this object to a String. - * If there is no element at that position, the result is undefined. - * If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos. - */ + * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point + * value of the UTF-16 encoded code point starting at the string element at position pos in + * the String resulting from converting this object to a String. + * If there is no element at that position, the result is undefined. + * If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos. + */ codePointAt(pos: number): number | undefined; /** - * Returns true if searchString appears as a substring of the result of converting this - * object to a String, at one or more positions that are - * greater than or equal to position; otherwise, returns false. - * @param searchString search string - * @param position If position is undefined, 0 is assumed, so as to search all of the String. - */ + * Returns true if searchString appears as a substring of the result of converting this + * object to a String, at one or more positions that are + * greater than or equal to position; otherwise, returns false. + * @param searchString search string + * @param position If position is undefined, 0 is assumed, so as to search all of the String. + */ includes(searchString: string, position?: number): boolean; /** - * Returns true if the sequence of elements of searchString converted to a String is the - * same as the corresponding elements of this object (converted to a String) starting at - * endPosition – length(this). Otherwise returns false. - */ + * Returns true if the sequence of elements of searchString converted to a String is the + * same as the corresponding elements of this object (converted to a String) starting at + * endPosition – length(this). Otherwise returns false. + */ endsWith(searchString: string, endPosition?: number): boolean; /** - * Returns the String value result of normalizing the string into the normalization form - * named by form as specified in Unicode Standard Annex #15, Unicode Normalization Forms. - * @param form Applicable values: "NFC", "NFD", "NFKC", or "NFKD", If not specified default - * is "NFC" - */ + * Returns the String value result of normalizing the string into the normalization form + * named by form as specified in Unicode Standard Annex #15, Unicode Normalization Forms. + * @param form Applicable values: "NFC", "NFD", "NFKC", or "NFKD", If not specified default + * is "NFC" + */ normalize(form: "NFC" | "NFD" | "NFKC" | "NFKD"): string; /** - * Returns the String value result of normalizing the string into the normalization form - * named by form as specified in Unicode Standard Annex #15, Unicode Normalization Forms. - * @param form Applicable values: "NFC", "NFD", "NFKC", or "NFKD", If not specified default - * is "NFC" - */ + * Returns the String value result of normalizing the string into the normalization form + * named by form as specified in Unicode Standard Annex #15, Unicode Normalization Forms. + * @param form Applicable values: "NFC", "NFD", "NFKC", or "NFKD", If not specified default + * is "NFC" + */ normalize(form?: string): string; /** - * Returns a String value that is made from count copies appended together. If count is 0, - * T is the empty String is returned. - * @param count number of copies to append - */ + * Returns a String value that is made from count copies appended together. If count is 0, + * T is the empty String is returned. + * @param count number of copies to append + */ repeat(count: number): string; /** - * Returns true if the sequence of elements of searchString converted to a String is the - * same as the corresponding elements of this object (converted to a String) starting at - * position. Otherwise returns false. - */ + * Returns true if the sequence of elements of searchString converted to a String is the + * same as the corresponding elements of this object (converted to a String) starting at + * position. Otherwise returns false. + */ startsWith(searchString: string, position?: number): boolean; /** - * Returns an HTML anchor element and sets the name attribute to the text value - * @param name - */ + * Returns an HTML anchor element and sets the name attribute to the text value + * @param name + */ anchor(name: string): string; /** Returns a HTML element */ @@ -518,17 +518,17 @@ interface String { interface StringConstructor { /** - * Return the String value whose elements are, in order, the elements in the List elements. - * If length is 0, the empty string is returned. - */ + * Return the String value whose elements are, in order, the elements in the List elements. + * If length is 0, the empty string is returned. + */ fromCodePoint(...codePoints: number[]): string; /** - * String.raw is intended for use as a tag function of a Tagged Template String. When called - * as such the first argument will be a well formed template call site object and the rest - * parameter will contain the substitution values. - * @param template A well-formed template string call site representation. - * @param substitutions A set of substitution values. - */ + * String.raw is intended for use as a tag function of a Tagged Template String. When called + * as such the first argument will be a well formed template call site object and the rest + * parameter will contain the substitution values. + * @param template A well-formed template string call site representation. + * @param substitutions A set of substitution values. + */ raw(template: TemplateStringsArray, ...substitutions: any[]): string; } diff --git a/src/lib/es2015.generator.d.ts b/src/lib/es2015.generator.d.ts index 5637ef816def8..8ea4f2f96300f 100644 --- a/src/lib/es2015.generator.d.ts +++ b/src/lib/es2015.generator.d.ts @@ -16,37 +16,37 @@ interface GeneratorFunction { */ readonly length: number; /** - * Returns the name of the function. - */ + * Returns the name of the function. + */ readonly name: string; /** - * A reference to the prototype. - */ + * A reference to the prototype. + */ readonly prototype: Generator; } interface GeneratorFunctionConstructor { /** - * Creates a new Generator function. - * @param args A list of arguments the function accepts. - */ + * Creates a new Generator function. + * @param args A list of arguments the function accepts. + */ new (...args: string[]): GeneratorFunction; /** - * Creates a new Generator function. - * @param args A list of arguments the function accepts. - */ + * Creates a new Generator function. + * @param args A list of arguments the function accepts. + */ (...args: string[]): GeneratorFunction; /** * The length of the arguments. */ readonly length: number; /** - * Returns the name of the function. - */ + * Returns the name of the function. + */ readonly name: string; /** - * A reference to the prototype. - */ + * A reference to the prototype. + */ readonly prototype: GeneratorFunction; } declare var GeneratorFunction: GeneratorFunctionConstructor; diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts index 73f0d45cda70e..03c583dc15587 100644 --- a/src/lib/es2015.iterable.d.ts +++ b/src/lib/es2015.iterable.d.ts @@ -2,9 +2,9 @@ interface SymbolConstructor { /** - * A method that returns the default iterator for an object. Called by the semantics of the - * for-of statement. - */ + * A method that returns the default iterator for an object. Called by the semantics of the + * for-of statement. + */ readonly iterator: symbol; } @@ -32,36 +32,36 @@ interface Array { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, T]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } interface ArrayConstructor { /** - * Creates an array from an iterable object. - * @param iterable An iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an iterable object. + * @param iterable An iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): Array; from(iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): Array; from(iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): Array; /** - * Creates an array from an iterable object. - * @param iterable An iterable object to convert to an array. - */ + * Creates an array from an iterable object. + * @param iterable An iterable object to convert to an array. + */ from(iterable: Iterable): Array; } @@ -70,18 +70,18 @@ interface ReadonlyArray { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, T]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -154,22 +154,22 @@ interface String { } /** - * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested - * number of bytes could not be allocated an exception is raised. - */ + * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested + * number of bytes could not be allocated an exception is raised. + */ interface Int8Array { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, number]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -177,11 +177,11 @@ interface Int8ArrayConstructor { new (elements: Iterable): Int8Array; /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; @@ -190,22 +190,22 @@ interface Int8ArrayConstructor { } /** - * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Uint8Array { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, number]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -213,11 +213,11 @@ interface Uint8ArrayConstructor { new (elements: Iterable): Uint8Array; /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; @@ -226,24 +226,24 @@ interface Uint8ArrayConstructor { } /** - * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0. - * If the requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0. + * If the requested number of bytes could not be allocated an exception is raised. + */ interface Uint8ClampedArray { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, number]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -252,11 +252,11 @@ interface Uint8ClampedArrayConstructor { /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; @@ -265,24 +265,24 @@ interface Uint8ClampedArrayConstructor { } /** - * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Int16Array { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, number]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -290,11 +290,11 @@ interface Int16ArrayConstructor { new (elements: Iterable): Int16Array; /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; @@ -303,22 +303,22 @@ interface Int16ArrayConstructor { } /** - * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Uint16Array { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, number]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -326,11 +326,11 @@ interface Uint16ArrayConstructor { new (elements: Iterable): Uint16Array; /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; @@ -339,22 +339,22 @@ interface Uint16ArrayConstructor { } /** - * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Int32Array { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, number]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -362,11 +362,11 @@ interface Int32ArrayConstructor { new (elements: Iterable): Int32Array; /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; @@ -375,22 +375,22 @@ interface Int32ArrayConstructor { } /** - * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Uint32Array { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, number]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -398,11 +398,11 @@ interface Uint32ArrayConstructor { new (elements: Iterable): Uint32Array; /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; @@ -411,22 +411,22 @@ interface Uint32ArrayConstructor { } /** - * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number - * of bytes could not be allocated an exception is raised. - */ + * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number + * of bytes could not be allocated an exception is raised. + */ interface Float32Array { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, number]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -434,11 +434,11 @@ interface Float32ArrayConstructor { new (elements: Iterable): Float32Array; /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; @@ -447,22 +447,22 @@ interface Float32ArrayConstructor { } /** - * A typed array of 64-bit float values. The contents are initialized to 0. If the requested - * number of bytes could not be allocated an exception is raised. - */ + * A typed array of 64-bit float values. The contents are initialized to 0. If the requested + * number of bytes could not be allocated an exception is raised. + */ interface Float64Array { [Symbol.iterator](): IterableIterator; /** - * Returns an array of key, value pairs for every entry in the array - */ + * Returns an array of key, value pairs for every entry in the array + */ entries(): IterableIterator<[number, number]>; /** - * Returns an list of keys in the array - */ + * Returns an list of keys in the array + */ keys(): IterableIterator; /** - * Returns an list of values in the array - */ + * Returns an list of values in the array + */ values(): IterableIterator; } @@ -470,11 +470,11 @@ interface Float64ArrayConstructor { new (elements: Iterable): Float64Array; /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; diff --git a/src/lib/es2015.promise.d.ts b/src/lib/es2015.promise.d.ts index 208e5c1cdc254..ab33531191ffc 100644 --- a/src/lib/es2015.promise.d.ts +++ b/src/lib/es2015.promise.d.ts @@ -1,7 +1,7 @@ interface PromiseConstructor { /** - * A reference to the prototype. - */ + * A reference to the prototype. + */ readonly prototype: Promise; /** @@ -187,10 +187,10 @@ interface PromiseConstructor { reject(reason: any): Promise; /** - * Creates a new resolved promise for the provided value. - * @param value A promise. - * @returns A promise whose internal state matches the provided promise. - */ + * Creates a new resolved promise for the provided value. + * @param value A promise. + * @returns A promise whose internal state matches the provided promise. + */ resolve(value: T | PromiseLike): Promise; /** diff --git a/src/lib/es2015.symbol.d.ts b/src/lib/es2015.symbol.d.ts index 44a5f17d742fe..8444ef2461818 100644 --- a/src/lib/es2015.symbol.d.ts +++ b/src/lib/es2015.symbol.d.ts @@ -8,28 +8,28 @@ interface Symbol { interface SymbolConstructor { /** - * A reference to the prototype. - */ + * A reference to the prototype. + */ readonly prototype: Symbol; /** - * Returns a new unique Symbol value. - * @param description Description of the new Symbol object. - */ + * Returns a new unique Symbol value. + * @param description Description of the new Symbol object. + */ (description?: string | number): symbol; /** - * Returns a Symbol object from the global symbol registry matching the given key if found. - * Otherwise, returns a new symbol with this key. - * @param key key to search for. - */ + * Returns a Symbol object from the global symbol registry matching the given key if found. + * Otherwise, returns a new symbol with this key. + * @param key key to search for. + */ for(key: string): symbol; /** - * Returns a key from the global symbol registry matching the given Symbol if found. - * Otherwise, returns a undefined. - * @param sym Symbol to find the key for. - */ + * Returns a key from the global symbol registry matching the given Symbol if found. + * Otherwise, returns a undefined. + * @param sym Symbol to find the key for. + */ keyFor(sym: symbol): string | undefined; } diff --git a/src/lib/es2015.symbol.wellknown.d.ts b/src/lib/es2015.symbol.wellknown.d.ts index 5334dae9e0198..578cf0acbc2f2 100644 --- a/src/lib/es2015.symbol.wellknown.d.ts +++ b/src/lib/es2015.symbol.wellknown.d.ts @@ -2,63 +2,63 @@ interface SymbolConstructor { /** - * A method that determines if a constructor object recognizes an object as one of the - * constructor’s instances. Called by the semantics of the instanceof operator. - */ + * A method that determines if a constructor object recognizes an object as one of the + * constructor’s instances. Called by the semantics of the instanceof operator. + */ readonly hasInstance: symbol; /** - * A Boolean value that if true indicates that an object should flatten to its array elements - * by Array.prototype.concat. - */ + * A Boolean value that if true indicates that an object should flatten to its array elements + * by Array.prototype.concat. + */ readonly isConcatSpreadable: symbol; /** - * A regular expression method that matches the regular expression against a string. Called - * by the String.prototype.match method. - */ + * A regular expression method that matches the regular expression against a string. Called + * by the String.prototype.match method. + */ readonly match: symbol; /** - * A regular expression method that replaces matched substrings of a string. Called by the - * String.prototype.replace method. - */ + * A regular expression method that replaces matched substrings of a string. Called by the + * String.prototype.replace method. + */ readonly replace: symbol; /** - * A regular expression method that returns the index within a string that matches the - * regular expression. Called by the String.prototype.search method. - */ + * A regular expression method that returns the index within a string that matches the + * regular expression. Called by the String.prototype.search method. + */ readonly search: symbol; /** - * A function valued property that is the constructor function that is used to create - * derived objects. - */ + * A function valued property that is the constructor function that is used to create + * derived objects. + */ readonly species: symbol; /** - * A regular expression method that splits a string at the indices that match the regular - * expression. Called by the String.prototype.split method. - */ + * A regular expression method that splits a string at the indices that match the regular + * expression. Called by the String.prototype.split method. + */ readonly split: symbol; /** - * A method that converts an object to a corresponding primitive value. - * Called by the ToPrimitive abstract operation. - */ + * A method that converts an object to a corresponding primitive value. + * Called by the ToPrimitive abstract operation. + */ readonly toPrimitive: symbol; /** - * A String value that is used in the creation of the default string description of an object. - * Called by the built-in method Object.prototype.toString. - */ + * A String value that is used in the creation of the default string description of an object. + * Called by the built-in method Object.prototype.toString. + */ readonly toStringTag: symbol; /** - * An Object whose own property names are property names that are excluded from the 'with' - * environment bindings of the associated objects. - */ + * An Object whose own property names are property names that are excluded from the 'with' + * environment bindings of the associated objects. + */ readonly unscopables: symbol; } @@ -154,50 +154,50 @@ interface PromiseConstructor { } interface RegExp { - /** - * Matches a string with this regular expression, and returns an array containing the results of - * that search. - * @param string A string to search within. - */ + /** + * Matches a string with this regular expression, and returns an array containing the results of + * that search. + * @param string A string to search within. + */ [Symbol.match](string: string): RegExpMatchArray | null; /** - * Replaces text in a string, using this regular expression. - * @param string A String object or string literal whose contents matching against - * this regular expression will be replaced - * @param replaceValue A String object or string literal containing the text to replace for every - * successful match of this regular expression. - */ + * Replaces text in a string, using this regular expression. + * @param string A String object or string literal whose contents matching against + * this regular expression will be replaced + * @param replaceValue A String object or string literal containing the text to replace for every + * successful match of this regular expression. + */ [Symbol.replace](string: string, replaceValue: string): string; /** - * Replaces text in a string, using this regular expression. - * @param string A String object or string literal whose contents matching against - * this regular expression will be replaced - * @param replacer A function that returns the replacement text. - */ + * Replaces text in a string, using this regular expression. + * @param string A String object or string literal whose contents matching against + * this regular expression will be replaced + * @param replacer A function that returns the replacement text. + */ [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string; /** - * Finds the position beginning first substring match in a regular expression search - * using this regular expression. - * - * @param string The string to search within. - */ + * Finds the position beginning first substring match in a regular expression search + * using this regular expression. + * + * @param string The string to search within. + */ [Symbol.search](string: string): number; /** - * Returns an array of substrings that were delimited by strings in the original input that - * match against this regular expression. - * - * If the regular expression contains capturing parentheses, then each time this - * regular expression matches, the results (including any undefined results) of the - * capturing parentheses are spliced. - * - * @param string string value to split - * @param limit if not undefined, the output array is truncated so that it contains no more - * than 'limit' elements. - */ + * Returns an array of substrings that were delimited by strings in the original input that + * match against this regular expression. + * + * If the regular expression contains capturing parentheses, then each time this + * regular expression matches, the results (including any undefined results) of the + * capturing parentheses are spliced. + * + * @param string string value to split + * @param limit if not undefined, the output array is truncated so that it contains no more + * than 'limit' elements. + */ [Symbol.split](string: string, limit?: number): string[]; } @@ -207,45 +207,45 @@ interface RegExpConstructor { interface String { /** - * Matches a string an object that supports being matched against, and returns an array containing the results of that search. - * @param matcher An object that supports being matched against. - */ + * Matches a string an object that supports being matched against, and returns an array containing the results of that search. + * @param matcher An object that supports being matched against. + */ match(matcher: { [Symbol.match](string: string): RegExpMatchArray | null; }): RegExpMatchArray | null; /** - * Replaces text in a string, using an object that supports replacement within a string. - * @param searchValue A object can search for and replace matches within a string. - * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string. - */ + * Replaces text in a string, using an object that supports replacement within a string. + * @param searchValue A object can search for and replace matches within a string. + * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string. + */ replace(searchValue: { [Symbol.replace](string: string, replaceValue: string): string; }, replaceValue: string): string; /** - * Replaces text in a string, using an object that supports replacement within a string. - * @param searchValue A object can search for and replace matches within a string. - * @param replacer A function that returns the replacement text. - */ + * Replaces text in a string, using an object that supports replacement within a string. + * @param searchValue A object can search for and replace matches within a string. + * @param replacer A function that returns the replacement text. + */ replace(searchValue: { [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string; }, replacer: (substring: string, ...args: any[]) => string): string; /** - * Finds the first substring match in a regular expression search. - * @param searcher An object which supports searching within a string. - */ + * Finds the first substring match in a regular expression search. + * @param searcher An object which supports searching within a string. + */ search(searcher: { [Symbol.search](string: string): number; }): number; /** - * Split a string into substrings using the specified separator and return them as an array. - * @param splitter An object that can split a string. - * @param limit A value used to limit the number of elements returned in the array. - */ + * Split a string into substrings using the specified separator and return them as an array. + * @param splitter An object that can split a string. + * @param limit A value used to limit the number of elements returned in the array. + */ split(splitter: { [Symbol.split](string: string, limit?: number): string[]; }, limit?: number): string[]; } /** - * Represents a raw buffer of binary data, which is used to store data for the - * different typed arrays. ArrayBuffers cannot be read from or written to directly, - * but can be passed to a typed array or DataView Object to interpret the raw - * buffer as needed. - */ + * Represents a raw buffer of binary data, which is used to store data for the + * different typed arrays. ArrayBuffers cannot be read from or written to directly, + * but can be passed to a typed array or DataView Object to interpret the raw + * buffer as needed. + */ interface ArrayBuffer { readonly [Symbol.toStringTag]: "ArrayBuffer"; } @@ -255,73 +255,73 @@ interface DataView { } /** - * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested - * number of bytes could not be allocated an exception is raised. - */ + * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested + * number of bytes could not be allocated an exception is raised. + */ interface Int8Array { readonly [Symbol.toStringTag]: "Int8Array"; } /** - * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Uint8Array { readonly [Symbol.toStringTag]: "UInt8Array"; } /** - * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0. - * If the requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0. + * If the requested number of bytes could not be allocated an exception is raised. + */ interface Uint8ClampedArray { readonly [Symbol.toStringTag]: "Uint8ClampedArray"; } /** - * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Int16Array { readonly [Symbol.toStringTag]: "Int16Array"; } /** - * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Uint16Array { readonly [Symbol.toStringTag]: "Uint16Array"; } /** - * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Int32Array { readonly [Symbol.toStringTag]: "Int32Array"; } /** - * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the - * requested number of bytes could not be allocated an exception is raised. - */ + * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the + * requested number of bytes could not be allocated an exception is raised. + */ interface Uint32Array { readonly [Symbol.toStringTag]: "Uint32Array"; } /** - * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number - * of bytes could not be allocated an exception is raised. - */ + * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number + * of bytes could not be allocated an exception is raised. + */ interface Float32Array { readonly [Symbol.toStringTag]: "Float32Array"; } /** - * A typed array of 64-bit float values. The contents are initialized to 0. If the requested - * number of bytes could not be allocated an exception is raised. - */ + * A typed array of 64-bit float values. The contents are initialized to 0. If the requested + * number of bytes could not be allocated an exception is raised. + */ interface Float64Array { readonly [Symbol.toStringTag]: "Float64Array"; } diff --git a/src/lib/es2016.array.include.d.ts b/src/lib/es2016.array.include.d.ts index fdd9ed4639fcd..1012c18407b0b 100644 --- a/src/lib/es2016.array.include.d.ts +++ b/src/lib/es2016.array.include.d.ts @@ -1,98 +1,98 @@ interface Array { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: T, fromIndex?: number): boolean; } interface ReadonlyArray { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: T, fromIndex?: number): boolean; } interface Int8Array { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: number, fromIndex?: number): boolean; } interface Uint8Array { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: number, fromIndex?: number): boolean; } interface Uint8ClampedArray { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: number, fromIndex?: number): boolean; } interface Int16Array { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: number, fromIndex?: number): boolean; } interface Uint16Array { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: number, fromIndex?: number): boolean; } interface Int32Array { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: number, fromIndex?: number): boolean; } interface Uint32Array { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: number, fromIndex?: number): boolean; } interface Float32Array { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: number, fromIndex?: number): boolean; } interface Float64Array { /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ includes(searchElement: number, fromIndex?: number): boolean; } \ No newline at end of file diff --git a/src/lib/es2017.object.d.ts b/src/lib/es2017.object.d.ts index 80c2161506a01..1f090a8fef2a1 100644 --- a/src/lib/es2017.object.d.ts +++ b/src/lib/es2017.object.d.ts @@ -1,25 +1,25 @@ interface ObjectConstructor { /** - * Returns an array of values of the enumerable properties of an object - * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object. - */ + * Returns an array of values of the enumerable properties of an object + * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object. + */ values(o: { [s: string]: T }): T[]; /** - * Returns an array of values of the enumerable properties of an object - * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object. - */ + * Returns an array of values of the enumerable properties of an object + * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object. + */ values(o: any): any[]; /** - * Returns an array of key/values of the enumerable properties of an object - * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object. - */ + * Returns an array of key/values of the enumerable properties of an object + * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object. + */ entries(o: { [s: string]: T }): [string, T][]; /** - * Returns an array of key/values of the enumerable properties of an object - * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object. - */ + * Returns an array of key/values of the enumerable properties of an object + * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object. + */ entries(o: any): [string, any][]; } diff --git a/src/lib/es2017.sharedmemory.d.ts b/src/lib/es2017.sharedmemory.d.ts index d9f986627ca1f..e18390a55919b 100644 --- a/src/lib/es2017.sharedmemory.d.ts +++ b/src/lib/es2017.sharedmemory.d.ts @@ -3,8 +3,8 @@ interface SharedArrayBuffer { /** - * Read-only. The length of the ArrayBuffer (in bytes). - */ + * Read-only. The length of the ArrayBuffer (in bytes). + */ readonly byteLength: number; /* @@ -12,8 +12,8 @@ interface SharedArrayBuffer { */ length: number; /** - * Returns a section of an SharedArrayBuffer. - */ + * Returns a section of an SharedArrayBuffer. + */ slice(begin: number, end?: number): SharedArrayBuffer; readonly [Symbol.species]: SharedArrayBuffer; readonly [Symbol.toStringTag]: "SharedArrayBuffer"; diff --git a/src/lib/es2017.string.d.ts b/src/lib/es2017.string.d.ts index 3a440f887e998..80139e3712ec5 100644 --- a/src/lib/es2017.string.d.ts +++ b/src/lib/es2017.string.d.ts @@ -1,27 +1,27 @@ interface String { /** - * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length. - * The padding is applied from the start (left) of the current string. - * - * @param maxLength The length of the resulting string once the current string has been padded. - * If this parameter is smaller than the current string's length, the current string will be returned as it is. - * - * @param fillString The string to pad the current string with. - * If this string is too long, it will be truncated and the left-most part will be applied. - * The default value for this parameter is " " (U+0020). - */ + * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length. + * The padding is applied from the start (left) of the current string. + * + * @param maxLength The length of the resulting string once the current string has been padded. + * If this parameter is smaller than the current string's length, the current string will be returned as it is. + * + * @param fillString The string to pad the current string with. + * If this string is too long, it will be truncated and the left-most part will be applied. + * The default value for this parameter is " " (U+0020). + */ padStart(maxLength: number, fillString?: string): string; /** - * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length. - * The padding is applied from the end (right) of the current string. - * - * @param maxLength The length of the resulting string once the current string has been padded. - * If this parameter is smaller than the current string's length, the current string will be returned as it is. - * - * @param fillString The string to pad the current string with. - * If this string is too long, it will be truncated and the left-most part will be applied. - * The default value for this parameter is " " (U+0020). - */ + * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length. + * The padding is applied from the end (right) of the current string. + * + * @param maxLength The length of the resulting string once the current string has been padded. + * If this parameter is smaller than the current string's length, the current string will be returned as it is. + * + * @param fillString The string to pad the current string with. + * If this string is too long, it will be truncated and the left-most part will be applied. + * The default value for this parameter is " " (U+0020). + */ padEnd(maxLength: number, fillString?: string): string; } diff --git a/src/lib/scripthost.d.ts b/src/lib/scripthost.d.ts index 8f10c631ec7a2..bec8be3173506 100644 --- a/src/lib/scripthost.d.ts +++ b/src/lib/scripthost.d.ts @@ -99,9 +99,9 @@ interface TextStreamReader extends TextStreamBase { declare var WScript: { /** - * Outputs text to either a message box (under WScript.exe) or the command console window followed by - * a newline (under CScript.exe). - */ + * Outputs text to either a message box (under WScript.exe) or the command console window followed by + * a newline (under CScript.exe). + */ Echo(s: any): void; /** diff --git a/src/server/builder.ts b/src/server/builder.ts index 108c0a0c64b31..bfd4f4ac8983e 100644 --- a/src/server/builder.ts +++ b/src/server/builder.ts @@ -191,7 +191,7 @@ namespace ts.server { const l = lf.scriptInfo.fileName; const r = rf.scriptInfo.fileName; return (l < r ? -1 : (l > r ? 1 : 0)); - }; + } static addToReferenceList(array: ModuleBuilderFileInfo[], fileInfo: ModuleBuilderFileInfo) { if (array.length === 0) { diff --git a/src/server/client.ts b/src/server/client.ts index ce7cef12c1140..623b00f1ed304 100644 --- a/src/server/client.ts +++ b/src/server/client.ts @@ -178,7 +178,8 @@ namespace ts.server { kindModifiers: response.body.kindModifiers, textSpan: ts.createTextSpanFromBounds(start, end), displayParts: [{ kind: "text", text: response.body.displayString }], - documentation: [{ kind: "text", text: response.body.documentation }] + documentation: [{ kind: "text", text: response.body.documentation }], + tags: response.body.tags }; } diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts index 8af6fe5d3471e..a1fd61e8fef5e 100644 --- a/src/server/editorServices.ts +++ b/src/server/editorServices.ts @@ -179,12 +179,12 @@ namespace ts.server { class DirectoryWatchers { /** * a path to directory watcher map that detects added tsconfig files - **/ + */ private readonly directoryWatchersForTsconfig: Map = createMap(); /** * count of how many projects are using the directory watcher. * If the number becomes 0 for a watcher, then we should close it. - **/ + */ private readonly directoryWatchersRefCount: Map = createMap(); constructor(private readonly projectService: ProjectService) { @@ -241,11 +241,11 @@ namespace ts.server { readonly externalProjects: ExternalProject[] = []; /** * projects built from openFileRoots - **/ + */ readonly inferredProjects: InferredProject[] = []; /** * projects specified by a tsconfig.json file - **/ + */ readonly configuredProjects: ConfiguredProject[] = []; /** * list of open files @@ -271,7 +271,8 @@ namespace ts.server { public readonly cancellationToken: HostCancellationToken, public readonly useSingleInferredProject: boolean, readonly typingsInstaller: ITypingsInstaller = nullTypingsInstaller, - private readonly eventHandler?: ProjectServiceEventHandler) { + private readonly eventHandler?: ProjectServiceEventHandler, + public readonly throttleWaitMilliseconds?: number) { Debug.assert(!!host.createHash, "'ServerHost.createHash' is required for ProjectService"); @@ -636,9 +637,9 @@ namespace ts.server { } /** - * Remove this file from the set of open, non-configured files. - * @param info The file that has been closed or newly configured - */ + * Remove this file from the set of open, non-configured files. + * @param info The file that has been closed or newly configured + */ private closeOpenFile(info: ScriptInfo): void { // Closing file should trigger re-reading the file content from disk. This is // because the user may chose to discard the buffer content before saving diff --git a/src/server/lsHost.ts b/src/server/lsHost.ts index eee80d82e7f11..ec655c545eab1 100644 --- a/src/server/lsHost.ts +++ b/src/server/lsHost.ts @@ -16,6 +16,7 @@ namespace ts.server { readonly realpath?: (path: string) => string; constructor(private readonly host: ServerHost, private readonly project: Project, private readonly cancellationToken: HostCancellationToken) { + this.cancellationToken = new ThrottledCancellationToken(cancellationToken, project.projectService.throttleWaitMilliseconds); this.getCanonicalFileName = ts.createGetCanonicalFileName(this.host.useCaseSensitiveFileNames); if (host.trace) { diff --git a/src/server/protocol.ts b/src/server/protocol.ts index 5096eefc1fcf6..71998666fedd0 100644 --- a/src/server/protocol.ts +++ b/src/server/protocol.ts @@ -1,6 +1,6 @@ /** - * Declaration module describing the TypeScript Server protocol - */ + * Declaration module describing the TypeScript Server protocol + */ namespace ts.server.protocol { export namespace CommandTypes { export type Brace = "brace"; @@ -98,99 +98,99 @@ namespace ts.server.protocol { } /** - * A TypeScript Server message - */ + * A TypeScript Server message + */ export interface Message { /** - * Sequence number of the message - */ + * Sequence number of the message + */ seq: number; /** - * One of "request", "response", or "event" - */ + * One of "request", "response", or "event" + */ type: "request" | "response" | "event"; } /** - * Client-initiated request message - */ + * Client-initiated request message + */ export interface Request extends Message { /** - * The command to execute - */ + * The command to execute + */ command: string; /** - * Object containing arguments for the command - */ + * Object containing arguments for the command + */ arguments?: any; } /** - * Request to reload the project structure for all the opened files - */ + * Request to reload the project structure for all the opened files + */ export interface ReloadProjectsRequest extends Message { command: CommandTypes.ReloadProjects; } /** - * Server-initiated event message - */ + * Server-initiated event message + */ export interface Event extends Message { /** - * Name of event - */ + * Name of event + */ event: string; /** - * Event-specific information - */ + * Event-specific information + */ body?: any; } /** - * Response by server to client request message. - */ + * Response by server to client request message. + */ export interface Response extends Message { /** - * Sequence number of the request message. - */ + * Sequence number of the request message. + */ request_seq: number; /** - * Outcome of the request. - */ + * Outcome of the request. + */ success: boolean; /** - * The command requested. - */ + * The command requested. + */ command: string; /** - * Contains error message if success === false. - */ + * Contains error message if success === false. + */ message?: string; /** - * Contains message body if success === true. - */ + * Contains message body if success === true. + */ body?: any; } /** - * Arguments for FileRequest messages. - */ + * Arguments for FileRequest messages. + */ export interface FileRequestArgs { /** - * The file for the request (absolute pathname required). - */ + * The file for the request (absolute pathname required). + */ file: string; /* - * Optional name of project that contains file - */ + * Optional name of project that contains file + */ projectFileName?: string; } @@ -290,18 +290,18 @@ namespace ts.server.protocol { } /** - * Arguments for ProjectInfoRequest request. - */ + * Arguments for ProjectInfoRequest request. + */ export interface ProjectInfoRequestArgs extends FileRequestArgs { /** - * Indicate if the file name list of the project is needed - */ + * Indicate if the file name list of the project is needed + */ needFileNameList: boolean; } /** - * A request to get the project information of the current file. - */ + * A request to get the project information of the current file. + */ export interface ProjectInfoRequest extends Request { command: CommandTypes.ProjectInfo; arguments: ProjectInfoRequestArgs; @@ -325,21 +325,21 @@ namespace ts.server.protocol { } /** - * Response message body for "projectInfo" request - */ + * Response message body for "projectInfo" request + */ export interface ProjectInfo { /** - * For configured project, this is the normalized path of the 'tsconfig.json' file - * For inferred project, this is undefined - */ + * For configured project, this is the normalized path of the 'tsconfig.json' file + * For inferred project, this is undefined + */ configFileName: string; /** - * The list of normalized file name in the project, including 'lib.d.ts' - */ + * The list of normalized file name in the project, including 'lib.d.ts' + */ fileNames?: string[]; /** - * Indicates if the project has a active language service instance - */ + * Indicates if the project has a active language service instance + */ languageServiceDisabled?: boolean; } @@ -359,32 +359,32 @@ namespace ts.server.protocol { } /** - * Response message for "projectInfo" request - */ + * Response message for "projectInfo" request + */ export interface ProjectInfoResponse extends Response { body?: ProjectInfo; } /** - * Request whose sole parameter is a file name. - */ + * Request whose sole parameter is a file name. + */ export interface FileRequest extends Request { arguments: FileRequestArgs; } /** - * Instances of this interface specify a location in a source file: - * (file, line, character offset), where line and character offset are 1-based. - */ + * Instances of this interface specify a location in a source file: + * (file, line, character offset), where line and character offset are 1-based. + */ export interface FileLocationRequestArgs extends FileRequestArgs { /** - * The line number for the request (1-based). - */ + * The line number for the request (1-based). + */ line: number; /** - * The character offset (on the line) for the request (1-based). - */ + * The character offset (on the line) for the request (1-based). + */ offset: number; /** @@ -395,25 +395,25 @@ namespace ts.server.protocol { } /** - * Request for the available codefixes at a specific position. - */ + * Request for the available codefixes at a specific position. + */ export interface CodeFixRequest extends Request { command: CommandTypes.GetCodeFixes; arguments: CodeFixRequestArgs; } /** - * Instances of this interface specify errorcodes on a specific location in a sourcefile. - */ + * Instances of this interface specify errorcodes on a specific location in a sourcefile. + */ export interface CodeFixRequestArgs extends FileRequestArgs { /** - * The line number for the request (1-based). - */ + * The line number for the request (1-based). + */ startLine: number; /** - * The character offset (on the line) for the request (1-based). - */ + * The character offset (on the line) for the request (1-based). + */ startOffset: number; /** @@ -423,13 +423,13 @@ namespace ts.server.protocol { startPosition?: number; /** - * The line number for the request (1-based). - */ + * The line number for the request (1-based). + */ endLine: number; /** - * The character offset (on the line) for the request (1-based). - */ + * The character offset (on the line) for the request (1-based). + */ endOffset: number; /** @@ -439,8 +439,8 @@ namespace ts.server.protocol { endPosition?: number; /** - * Errorcodes we want to get the fixes for. - */ + * Errorcodes we want to get the fixes for. + */ errorCodes?: number[]; } @@ -452,8 +452,8 @@ namespace ts.server.protocol { } /** - * A request whose arguments specify a file location (file, line, col). - */ + * A request whose arguments specify a file location (file, line, col). + */ export interface FileLocationRequest extends FileRequest { arguments: FileLocationRequestArgs; } @@ -498,9 +498,9 @@ namespace ts.server.protocol { } /** - * Arguments in document highlight request; include: filesToSearch, file, - * line, offset. - */ + * Arguments in document highlight request; include: filesToSearch, file, + * line, offset. + */ export interface DocumentHighlightsRequestArgs extends FileLocationRequestArgs { /** * List of files to search for document highlights. @@ -509,82 +509,82 @@ namespace ts.server.protocol { } /** - * Go to definition request; value of command field is - * "definition". Return response giving the file locations that - * define the symbol found in file at location line, col. - */ + * Go to definition request; value of command field is + * "definition". Return response giving the file locations that + * define the symbol found in file at location line, col. + */ export interface DefinitionRequest extends FileLocationRequest { command: CommandTypes.Definition; } /** - * Go to type request; value of command field is - * "typeDefinition". Return response giving the file locations that - * define the type for the symbol found in file at location line, col. - */ + * Go to type request; value of command field is + * "typeDefinition". Return response giving the file locations that + * define the type for the symbol found in file at location line, col. + */ export interface TypeDefinitionRequest extends FileLocationRequest { command: CommandTypes.TypeDefinition; } /** - * Go to implementation request; value of command field is - * "implementation". Return response giving the file locations that - * implement the symbol found in file at location line, col. - */ + * Go to implementation request; value of command field is + * "implementation". Return response giving the file locations that + * implement the symbol found in file at location line, col. + */ export interface ImplementationRequest extends FileLocationRequest { command: CommandTypes.Implementation; } /** - * Location in source code expressed as (one-based) line and character offset. - */ + * Location in source code expressed as (one-based) line and character offset. + */ export interface Location { line: number; offset: number; } /** - * Object found in response messages defining a span of text in source code. - */ + * Object found in response messages defining a span of text in source code. + */ export interface TextSpan { /** - * First character of the definition. - */ + * First character of the definition. + */ start: Location; /** - * One character past last character of the definition. - */ + * One character past last character of the definition. + */ end: Location; } /** - * Object found in response messages defining a span of text in a specific source file. - */ + * Object found in response messages defining a span of text in a specific source file. + */ export interface FileSpan extends TextSpan { /** - * File containing text span. - */ + * File containing text span. + */ file: string; } /** - * Definition response message. Gives text range for definition. - */ + * Definition response message. Gives text range for definition. + */ export interface DefinitionResponse extends Response { body?: FileSpan[]; } /** - * Definition response message. Gives text range for definition. - */ + * Definition response message. Gives text range for definition. + */ export interface TypeDefinitionResponse extends Response { body?: FileSpan[]; } /** - * Implementation response message. Gives text range for implementations. - */ + * Implementation response message. Gives text range for implementations. + */ export interface ImplementationResponse extends Response { body?: FileSpan[]; } @@ -608,18 +608,18 @@ namespace ts.server.protocol { } /** - * Get occurrences request; value of command field is - * "occurrences". Return response giving spans that are relevant - * in the file at a given line and column. - */ + * Get occurrences request; value of command field is + * "occurrences". Return response giving spans that are relevant + * in the file at a given line and column. + */ export interface OccurrencesRequest extends FileLocationRequest { command: CommandTypes.Occurrences; } export interface OccurrencesResponseItem extends FileSpan { /** - * True if the occurrence is a write location, false otherwise. - */ + * True if the occurrence is a write location, false otherwise. + */ isWriteAccess: boolean; /** @@ -633,10 +633,10 @@ namespace ts.server.protocol { } /** - * Get document highlights request; value of command field is - * "documentHighlights". Return response giving spans that are relevant - * in the file at a given line and column. - */ + * Get document highlights request; value of command field is + * "documentHighlights". Return response giving spans that are relevant + * in the file at a given line and column. + */ export interface DocumentHighlightsRequest extends FileLocationRequest { command: CommandTypes.DocumentHighlights; arguments: DocumentHighlightsRequestArgs; @@ -655,13 +655,13 @@ namespace ts.server.protocol { */ export interface DocumentHighlightsItem { /** - * File containing highlight spans. - */ + * File containing highlight spans. + */ file: string; /** - * Spans to highlight in file. - */ + * Spans to highlight in file. + */ highlightSpans: HighlightSpan[]; } @@ -673,25 +673,25 @@ namespace ts.server.protocol { } /** - * Find references request; value of command field is - * "references". Return response giving the file locations that - * reference the symbol found in file at location line, col. - */ + * Find references request; value of command field is + * "references". Return response giving the file locations that + * reference the symbol found in file at location line, col. + */ export interface ReferencesRequest extends FileLocationRequest { command: CommandTypes.References; } export interface ReferencesResponseItem extends FileSpan { /** Text of line containing the reference. Including this - * with the response avoids latency of editor loading files - * to show text of reference line (the server already has - * loaded the referencing files). - */ + * with the response avoids latency of editor loading files + * to show text of reference line (the server already has + * loaded the referencing files). + */ lineText: string; /** - * True if reference is a write location, false otherwise. - */ + * True if reference is a write location, false otherwise. + */ isWriteAccess: boolean; /** @@ -701,33 +701,33 @@ namespace ts.server.protocol { } /** - * The body of a "references" response message. - */ + * The body of a "references" response message. + */ export interface ReferencesResponseBody { /** - * The file locations referencing the symbol. - */ + * The file locations referencing the symbol. + */ refs: ReferencesResponseItem[]; /** - * The name of the symbol. - */ + * The name of the symbol. + */ symbolName: string; /** - * The start character offset of the symbol (on the line provided by the references request). - */ + * The start character offset of the symbol (on the line provided by the references request). + */ symbolStartOffset: number; /** - * The full display name of the symbol. - */ + * The full display name of the symbol. + */ symbolDisplayString: string; } /** - * Response to "references" request. - */ + * Response to "references" request. + */ export interface ReferencesResponse extends Response { body?: ReferencesResponseBody; } @@ -747,48 +747,48 @@ namespace ts.server.protocol { } /** - * Rename request; value of command field is "rename". Return - * response giving the file locations that reference the symbol - * found in file at location line, col. Also return full display - * name of the symbol so that client can print it unambiguously. - */ + * Rename request; value of command field is "rename". Return + * response giving the file locations that reference the symbol + * found in file at location line, col. Also return full display + * name of the symbol so that client can print it unambiguously. + */ export interface RenameRequest extends FileLocationRequest { command: CommandTypes.Rename; arguments: RenameRequestArgs; } /** - * Information about the item to be renamed. - */ + * Information about the item to be renamed. + */ export interface RenameInfo { /** - * True if item can be renamed. - */ + * True if item can be renamed. + */ canRename: boolean; /** - * Error message if item can not be renamed. - */ + * Error message if item can not be renamed. + */ localizedErrorMessage?: string; /** - * Display name of the item to be renamed. - */ + * Display name of the item to be renamed. + */ displayName: string; /** - * Full display name of item to be renamed. - */ + * Full display name of item to be renamed. + */ fullDisplayName: string; /** - * The items's kind (such as 'className' or 'parameterName' or plain 'text'). - */ + * The items's kind (such as 'className' or 'parameterName' or plain 'text'). + */ kind: string; /** - * Optional modifiers for the kind (such as 'public'). - */ + * Optional modifiers for the kind (such as 'public'). + */ kindModifiers: string; } @@ -815,8 +815,8 @@ namespace ts.server.protocol { } /** - * Rename response message. - */ + * Rename response message. + */ export interface RenameResponse extends Response { body?: RenameResponseBody; } @@ -985,19 +985,19 @@ namespace ts.server.protocol { /** - * Information found in a configure request. - */ + * Information found in a configure request. + */ export interface ConfigureRequestArguments { /** - * Information about the host, for example 'Emacs 24.4' or - * 'Sublime Text version 3075' - */ + * Information about the host, for example 'Emacs 24.4' or + * 'Sublime Text version 3075' + */ hostInfo?: string; /** - * If present, tab settings apply only to this file. - */ + * If present, tab settings apply only to this file. + */ file?: string; /** @@ -1012,24 +1012,24 @@ namespace ts.server.protocol { } /** - * Configure request; value of command field is "configure". Specifies - * host information, such as host type, tab size, and indent size. - */ + * Configure request; value of command field is "configure". Specifies + * host information, such as host type, tab size, and indent size. + */ export interface ConfigureRequest extends Request { command: CommandTypes.Configure; arguments: ConfigureRequestArguments; } /** - * Response to "configure" request. This is just an acknowledgement, so - * no body field is required. - */ + * Response to "configure" request. This is just an acknowledgement, so + * no body field is required. + */ export interface ConfigureResponse extends Response { } /** - * Information found in an "open" request. - */ + * Information found in an "open" request. + */ export interface OpenRequestArgs extends FileRequestArgs { /** * Used when a version of the file content is known to be more up to date than the one on disk. @@ -1046,13 +1046,13 @@ namespace ts.server.protocol { export type ScriptKindName = "TS" | "JS" | "TSX" | "JSX"; /** - * Open request; value of command field is "open". Notify the - * server that the client has file open. The server will not - * monitor the filesystem for changes in this file and will assume - * that the client is updating the server (using the change and/or - * reload messages) when the file changes. Server does not currently - * send a response to an open request. - */ + * Open request; value of command field is "open". Notify the + * server that the client has file open. The server will not + * monitor the filesystem for changes in this file and will assume + * that the client is updating the server (using the change and/or + * reload messages) when the file changes. Server does not currently + * send a response to an open request. + */ export interface OpenRequest extends Request { command: CommandTypes.Open; arguments: OpenRequestArgs; @@ -1199,27 +1199,27 @@ namespace ts.server.protocol { } /** - * Response to SetCompilerOptionsForInferredProjectsResponse request. This is just an acknowledgement, so - * no body field is required. - */ + * Response to SetCompilerOptionsForInferredProjectsResponse request. This is just an acknowledgement, so + * no body field is required. + */ export interface SetCompilerOptionsForInferredProjectsResponse extends Response { } /** - * Exit request; value of command field is "exit". Ask the server process - * to exit. - */ + * Exit request; value of command field is "exit". Ask the server process + * to exit. + */ export interface ExitRequest extends Request { command: CommandTypes.Exit; } /** - * Close request; value of command field is "close". Notify the - * server that the client has closed a previously open file. If - * file is still referenced by open files, the server will resume - * monitoring the filesystem for changes to file. Server does not - * currently send a response to a close request. - */ + * Close request; value of command field is "close". Notify the + * server that the client has closed a previously open file. If + * file is still referenced by open files, the server will resume + * monitoring the filesystem for changes to file. Server does not + * currently send a response to a close request. + */ export interface CloseRequest extends FileRequest { command: CommandTypes.Close; } @@ -1277,69 +1277,74 @@ namespace ts.server.protocol { } /** - * Quickinfo request; value of command field is - * "quickinfo". Return response giving a quick type and - * documentation string for the symbol found in file at location - * line, col. - */ + * Quickinfo request; value of command field is + * "quickinfo". Return response giving a quick type and + * documentation string for the symbol found in file at location + * line, col. + */ export interface QuickInfoRequest extends FileLocationRequest { command: CommandTypes.Quickinfo; } /** - * Body of QuickInfoResponse. - */ + * Body of QuickInfoResponse. + */ export interface QuickInfoResponseBody { /** - * The symbol's kind (such as 'className' or 'parameterName' or plain 'text'). - */ + * The symbol's kind (such as 'className' or 'parameterName' or plain 'text'). + */ kind: string; /** - * Optional modifiers for the kind (such as 'public'). - */ + * Optional modifiers for the kind (such as 'public'). + */ kindModifiers: string; /** - * Starting file location of symbol. - */ + * Starting file location of symbol. + */ start: Location; /** - * One past last character of symbol. - */ + * One past last character of symbol. + */ end: Location; /** - * Type and kind of symbol. - */ + * Type and kind of symbol. + */ displayString: string; /** - * Documentation associated with symbol. - */ + * Documentation associated with symbol. + */ documentation: string; + + /** + * JSDoc tags associated with symbol. + */ + tags: JSDocTagInfo[]; } /** - * Quickinfo response message. - */ + * Quickinfo response message. + */ export interface QuickInfoResponse extends Response { body?: QuickInfoResponseBody; } /** - * Arguments for format messages. - */ + * Arguments for format messages. + */ export interface FormatRequestArgs extends FileLocationRequestArgs { /** - * Last line of range for which to format text in file. - */ + * Last line of range for which to format text in file. + */ endLine: number; /** - * Character offset on last line of range for which to format text in file. - */ + * Character offset on last line of range for which to format text in file. + */ endOffset: number; /** @@ -1354,39 +1359,39 @@ namespace ts.server.protocol { } /** - * Format request; value of command field is "format". Return - * response giving zero or more edit instructions. The edit - * instructions will be sorted in file order. Applying the edit - * instructions in reverse to file will result in correctly - * reformatted text. - */ + * Format request; value of command field is "format". Return + * response giving zero or more edit instructions. The edit + * instructions will be sorted in file order. Applying the edit + * instructions in reverse to file will result in correctly + * reformatted text. + */ export interface FormatRequest extends FileLocationRequest { command: CommandTypes.Format; arguments: FormatRequestArgs; } /** - * Object found in response messages defining an editing - * instruction for a span of text in source code. The effect of - * this instruction is to replace the text starting at start and - * ending one character before end with newText. For an insertion, - * the text span is empty. For a deletion, newText is empty. - */ + * Object found in response messages defining an editing + * instruction for a span of text in source code. The effect of + * this instruction is to replace the text starting at start and + * ending one character before end with newText. For an insertion, + * the text span is empty. For a deletion, newText is empty. + */ export interface CodeEdit { /** - * First character of the text span to edit. - */ + * First character of the text span to edit. + */ start: Location; /** - * One character past last character of the text span to edit. - */ + * One character past last character of the text span to edit. + */ end: Location; /** - * Replace the span defined above with this string (may be - * the empty string). - */ + * Replace the span defined above with this string (may be + * the empty string). + */ newText: string; } @@ -1408,109 +1413,109 @@ namespace ts.server.protocol { } /** - * Format and format on key response message. - */ + * Format and format on key response message. + */ export interface FormatResponse extends Response { body?: CodeEdit[]; } /** - * Arguments for format on key messages. - */ + * Arguments for format on key messages. + */ export interface FormatOnKeyRequestArgs extends FileLocationRequestArgs { /** - * Key pressed (';', '\n', or '}'). - */ + * Key pressed (';', '\n', or '}'). + */ key: string; options?: FormatCodeSettings; } /** - * Format on key request; value of command field is - * "formatonkey". Given file location and key typed (as string), - * return response giving zero or more edit instructions. The - * edit instructions will be sorted in file order. Applying the - * edit instructions in reverse to file will result in correctly - * reformatted text. - */ + * Format on key request; value of command field is + * "formatonkey". Given file location and key typed (as string), + * return response giving zero or more edit instructions. The + * edit instructions will be sorted in file order. Applying the + * edit instructions in reverse to file will result in correctly + * reformatted text. + */ export interface FormatOnKeyRequest extends FileLocationRequest { command: CommandTypes.Formatonkey; arguments: FormatOnKeyRequestArgs; } /** - * Arguments for completions messages. - */ + * Arguments for completions messages. + */ export interface CompletionsRequestArgs extends FileLocationRequestArgs { /** - * Optional prefix to apply to possible completions. - */ + * Optional prefix to apply to possible completions. + */ prefix?: string; } /** - * Completions request; value of command field is "completions". - * Given a file location (file, line, col) and a prefix (which may - * be the empty string), return the possible completions that - * begin with prefix. - */ + * Completions request; value of command field is "completions". + * Given a file location (file, line, col) and a prefix (which may + * be the empty string), return the possible completions that + * begin with prefix. + */ export interface CompletionsRequest extends FileLocationRequest { command: CommandTypes.Completions; arguments: CompletionsRequestArgs; } /** - * Arguments for completion details request. - */ + * Arguments for completion details request. + */ export interface CompletionDetailsRequestArgs extends FileLocationRequestArgs { /** - * Names of one or more entries for which to obtain details. - */ + * Names of one or more entries for which to obtain details. + */ entryNames: string[]; } /** - * Completion entry details request; value of command field is - * "completionEntryDetails". Given a file location (file, line, - * col) and an array of completion entry names return more - * detailed information for each completion entry. - */ + * Completion entry details request; value of command field is + * "completionEntryDetails". Given a file location (file, line, + * col) and an array of completion entry names return more + * detailed information for each completion entry. + */ export interface CompletionDetailsRequest extends FileLocationRequest { command: CommandTypes.CompletionDetails; arguments: CompletionDetailsRequestArgs; } /** - * Part of a symbol description. - */ + * Part of a symbol description. + */ export interface SymbolDisplayPart { /** - * Text of an item describing the symbol. - */ + * Text of an item describing the symbol. + */ text: string; /** - * The symbol's kind (such as 'className' or 'parameterName' or plain 'text'). - */ + * The symbol's kind (such as 'className' or 'parameterName' or plain 'text'). + */ kind: string; } /** - * An item found in a completion response. - */ + * An item found in a completion response. + */ export interface CompletionEntry { /** - * The symbol's name. - */ + * The symbol's name. + */ name: string; /** - * The symbol's kind (such as 'className' or 'parameterName'). - */ + * The symbol's kind (such as 'className' or 'parameterName'). + */ kind: string; /** - * Optional modifiers for the kind (such as 'public'). - */ + * Optional modifiers for the kind (such as 'public'). + */ kindModifiers: string; /** * A string that is used for comparing completion items so that they can be ordered. This @@ -1525,30 +1530,35 @@ namespace ts.server.protocol { } /** - * Additional completion entry details, available on demand - */ + * Additional completion entry details, available on demand + */ export interface CompletionEntryDetails { /** - * The symbol's name. - */ + * The symbol's name. + */ name: string; /** - * The symbol's kind (such as 'className' or 'parameterName'). - */ + * The symbol's kind (such as 'className' or 'parameterName'). + */ kind: string; /** - * Optional modifiers for the kind (such as 'public'). - */ + * Optional modifiers for the kind (such as 'public'). + */ kindModifiers: string; /** - * Display parts of the symbol (similar to quick info). - */ + * Display parts of the symbol (similar to quick info). + */ displayParts: SymbolDisplayPart[]; /** - * Documentation strings for the symbol. - */ + * Documentation strings for the symbol. + */ documentation: SymbolDisplayPart[]; + + /** + * JSDoc tags for the symbol. + */ + tags: JSDocTagInfo[]; } export interface CompletionsResponse extends Response { @@ -1570,13 +1580,13 @@ namespace ts.server.protocol { name: string; /** - * Documentation of the parameter. - */ + * Documentation of the parameter. + */ documentation: SymbolDisplayPart[]; /** - * Display parts of the parameter. - */ + * Display parts of the parameter. + */ displayParts: SymbolDisplayPart[]; /** @@ -1619,6 +1629,11 @@ namespace ts.server.protocol { * The signature's documentation */ documentation: SymbolDisplayPart[]; + + /** + * The signature's JSDoc tags + */ + tags: JSDocTagInfo[]; } /** @@ -1659,10 +1674,10 @@ namespace ts.server.protocol { } /** - * Signature help request; value of command field is "signatureHelp". - * Given a file location (file, line, col), return the signature - * help. - */ + * Signature help request; value of command field is "signatureHelp". + * Given a file location (file, line, col), return the signature + * help. + */ export interface SignatureHelpRequest extends FileLocationRequest { command: CommandTypes.SignatureHelp; arguments: SignatureHelpRequestArgs; @@ -1676,8 +1691,8 @@ namespace ts.server.protocol { } /** - * Synchronous request for semantic diagnostics of one file. - */ + * Synchronous request for semantic diagnostics of one file. + */ export interface SemanticDiagnosticsSyncRequest extends FileRequest { command: CommandTypes.SemanticDiagnosticsSync; arguments: SemanticDiagnosticsSyncRequestArgs; @@ -1688,15 +1703,15 @@ namespace ts.server.protocol { } /** - * Response object for synchronous sematic diagnostics request. - */ + * Response object for synchronous sematic diagnostics request. + */ export interface SemanticDiagnosticsSyncResponse extends Response { body?: Diagnostic[] | DiagnosticWithLinePosition[]; } /** - * Synchronous request for syntactic diagnostics of one file. - */ + * Synchronous request for syntactic diagnostics of one file. + */ export interface SyntacticDiagnosticsSyncRequest extends FileRequest { command: CommandTypes.SyntacticDiagnosticsSync; arguments: SyntacticDiagnosticsSyncRequestArgs; @@ -1707,65 +1722,65 @@ namespace ts.server.protocol { } /** - * Response object for synchronous syntactic diagnostics request. - */ + * Response object for synchronous syntactic diagnostics request. + */ export interface SyntacticDiagnosticsSyncResponse extends Response { body?: Diagnostic[] | DiagnosticWithLinePosition[]; } /** - * Arguments for GeterrForProject request. - */ + * Arguments for GeterrForProject request. + */ export interface GeterrForProjectRequestArgs { /** - * the file requesting project error list - */ + * the file requesting project error list + */ file: string; /** - * Delay in milliseconds to wait before starting to compute - * errors for the files in the file list - */ + * Delay in milliseconds to wait before starting to compute + * errors for the files in the file list + */ delay: number; } /** - * GeterrForProjectRequest request; value of command field is - * "geterrForProject". It works similarly with 'Geterr', only - * it request for every file in this project. - */ + * GeterrForProjectRequest request; value of command field is + * "geterrForProject". It works similarly with 'Geterr', only + * it request for every file in this project. + */ export interface GeterrForProjectRequest extends Request { command: CommandTypes.GeterrForProject; arguments: GeterrForProjectRequestArgs; } /** - * Arguments for geterr messages. - */ + * Arguments for geterr messages. + */ export interface GeterrRequestArgs { /** - * List of file names for which to compute compiler errors. - * The files will be checked in list order. - */ + * List of file names for which to compute compiler errors. + * The files will be checked in list order. + */ files: string[]; /** - * Delay in milliseconds to wait before starting to compute - * errors for the files in the file list - */ + * Delay in milliseconds to wait before starting to compute + * errors for the files in the file list + */ delay: number; } /** - * Geterr request; value of command field is "geterr". Wait for - * delay milliseconds and then, if during the wait no change or - * reload messages have arrived for the first file in the files - * list, get the syntactic errors for the file, field requests, - * and then get the semantic errors for the file. Repeat with a - * smaller delay for each subsequent file on the files list. Best - * practice for an editor is to send a file list containing each - * file that is currently visible, in most-recently-used order. - */ + * Geterr request; value of command field is "geterr". Wait for + * delay milliseconds and then, if during the wait no change or + * reload messages have arrived for the first file in the files + * list, get the syntactic errors for the file, field requests, + * and then get the semantic errors for the file. Repeat with a + * smaller delay for each subsequent file on the files list. Best + * practice for an editor is to send a file list containing each + * file that is currently visible, in most-recently-used order. + */ export interface GeterrRequest extends Request { command: CommandTypes.Geterr; arguments: GeterrRequestArgs; @@ -1786,46 +1801,46 @@ namespace ts.server.protocol { } /** - * Item of diagnostic information found in a DiagnosticEvent message. - */ + * Item of diagnostic information found in a DiagnosticEvent message. + */ export interface Diagnostic { /** - * Starting file location at which text applies. - */ + * Starting file location at which text applies. + */ start: Location; /** - * The last file location at which the text applies. - */ + * The last file location at which the text applies. + */ end: Location; /** - * Text of diagnostic message. - */ + * Text of diagnostic message. + */ text: string; /** - * The error code of the diagnostic message. - */ + * The error code of the diagnostic message. + */ code?: number; } export interface DiagnosticEventBody { /** - * The file for which diagnostic information is reported. - */ + * The file for which diagnostic information is reported. + */ file: string; /** - * An array of diagnostic information items. - */ + * An array of diagnostic information items. + */ diagnostics: Diagnostic[]; } /** - * Event message for "syntaxDiag" and "semanticDiag" event types. - * These events provide syntactic and semantic errors for a file. - */ + * Event message for "syntaxDiag" and "semanticDiag" event types. + * These events provide syntactic and semantic errors for a file. + */ export interface DiagnosticEvent extends Event { body?: DiagnosticEventBody; } @@ -1878,195 +1893,195 @@ namespace ts.server.protocol { } /** - * Arguments for reload request. - */ + * Arguments for reload request. + */ export interface ReloadRequestArgs extends FileRequestArgs { /** - * Name of temporary file from which to reload file - * contents. May be same as file. - */ + * Name of temporary file from which to reload file + * contents. May be same as file. + */ tmpfile: string; } /** - * Reload request message; value of command field is "reload". - * Reload contents of file with name given by the 'file' argument - * from temporary file with name given by the 'tmpfile' argument. - * The two names can be identical. - */ + * Reload request message; value of command field is "reload". + * Reload contents of file with name given by the 'file' argument + * from temporary file with name given by the 'tmpfile' argument. + * The two names can be identical. + */ export interface ReloadRequest extends FileRequest { command: CommandTypes.Reload; arguments: ReloadRequestArgs; } /** - * Response to "reload" request. This is just an acknowledgement, so - * no body field is required. - */ + * Response to "reload" request. This is just an acknowledgement, so + * no body field is required. + */ export interface ReloadResponse extends Response { } /** - * Arguments for saveto request. - */ + * Arguments for saveto request. + */ export interface SavetoRequestArgs extends FileRequestArgs { /** - * Name of temporary file into which to save server's view of - * file contents. - */ + * Name of temporary file into which to save server's view of + * file contents. + */ tmpfile: string; } /** - * Saveto request message; value of command field is "saveto". - * For debugging purposes, save to a temporaryfile (named by - * argument 'tmpfile') the contents of file named by argument - * 'file'. The server does not currently send a response to a - * "saveto" request. - */ + * Saveto request message; value of command field is "saveto". + * For debugging purposes, save to a temporaryfile (named by + * argument 'tmpfile') the contents of file named by argument + * 'file'. The server does not currently send a response to a + * "saveto" request. + */ export interface SavetoRequest extends FileRequest { command: CommandTypes.Saveto; arguments: SavetoRequestArgs; } /** - * Arguments for navto request message. - */ + * Arguments for navto request message. + */ export interface NavtoRequestArgs extends FileRequestArgs { /** - * Search term to navigate to from current location; term can - * be '.*' or an identifier prefix. - */ + * Search term to navigate to from current location; term can + * be '.*' or an identifier prefix. + */ searchValue: string; /** - * Optional limit on the number of items to return. - */ + * Optional limit on the number of items to return. + */ maxResultCount?: number; /** - * Optional flag to indicate we want results for just the current file - * or the entire project. - */ + * Optional flag to indicate we want results for just the current file + * or the entire project. + */ currentFileOnly?: boolean; projectFileName?: string; } /** - * Navto request message; value of command field is "navto". - * Return list of objects giving file locations and symbols that - * match the search term given in argument 'searchTerm'. The - * context for the search is given by the named file. - */ + * Navto request message; value of command field is "navto". + * Return list of objects giving file locations and symbols that + * match the search term given in argument 'searchTerm'. The + * context for the search is given by the named file. + */ export interface NavtoRequest extends FileRequest { command: CommandTypes.Navto; arguments: NavtoRequestArgs; } /** - * An item found in a navto response. - */ + * An item found in a navto response. + */ export interface NavtoItem { /** - * The symbol's name. - */ + * The symbol's name. + */ name: string; /** - * The symbol's kind (such as 'className' or 'parameterName'). - */ + * The symbol's kind (such as 'className' or 'parameterName'). + */ kind: string; /** - * exact, substring, or prefix. - */ + * exact, substring, or prefix. + */ matchKind?: string; /** - * If this was a case sensitive or insensitive match. - */ + * If this was a case sensitive or insensitive match. + */ isCaseSensitive?: boolean; /** - * Optional modifiers for the kind (such as 'public'). - */ + * Optional modifiers for the kind (such as 'public'). + */ kindModifiers?: string; /** - * The file in which the symbol is found. - */ + * The file in which the symbol is found. + */ file: string; /** - * The location within file at which the symbol is found. - */ + * The location within file at which the symbol is found. + */ start: Location; /** - * One past the last character of the symbol. - */ + * One past the last character of the symbol. + */ end: Location; /** - * Name of symbol's container symbol (if any); for example, - * the class name if symbol is a class member. - */ + * Name of symbol's container symbol (if any); for example, + * the class name if symbol is a class member. + */ containerName?: string; /** - * Kind of symbol's container symbol (if any). - */ + * Kind of symbol's container symbol (if any). + */ containerKind?: string; } /** - * Navto response message. Body is an array of navto items. Each - * item gives a symbol that matched the search term. - */ + * Navto response message. Body is an array of navto items. Each + * item gives a symbol that matched the search term. + */ export interface NavtoResponse extends Response { body?: NavtoItem[]; } /** - * Arguments for change request message. - */ + * Arguments for change request message. + */ export interface ChangeRequestArgs extends FormatRequestArgs { /** - * Optional string to insert at location (file, line, offset). - */ + * Optional string to insert at location (file, line, offset). + */ insertString?: string; } /** - * Change request message; value of command field is "change". - * Update the server's view of the file named by argument 'file'. - * Server does not currently send a response to a change request. - */ + * Change request message; value of command field is "change". + * Update the server's view of the file named by argument 'file'. + * Server does not currently send a response to a change request. + */ export interface ChangeRequest extends FileLocationRequest { command: CommandTypes.Change; arguments: ChangeRequestArgs; } /** - * Response to "brace" request. - */ + * Response to "brace" request. + */ export interface BraceResponse extends Response { body?: TextSpan[]; } /** - * Brace matching request; value of command field is "brace". - * Return response giving the file locations of matching braces - * found in file at location line, offset. - */ + * Brace matching request; value of command field is "brace". + * Return response giving the file locations of matching braces + * found in file at location line, offset. + */ export interface BraceRequest extends FileLocationRequest { command: CommandTypes.Brace; } /** - * NavBar items request; value of command field is "navbar". - * Return response giving the list of navigation bar entries - * extracted from the requested file. - */ + * NavBar items request; value of command field is "navbar". + * Return response giving the list of navigation bar entries + * extracted from the requested file. + */ export interface NavBarRequest extends FileRequest { command: CommandTypes.NavBar; } @@ -2081,33 +2096,33 @@ namespace ts.server.protocol { export interface NavigationBarItem { /** - * The item's display text. - */ + * The item's display text. + */ text: string; /** - * The symbol's kind (such as 'className' or 'parameterName'). - */ + * The symbol's kind (such as 'className' or 'parameterName'). + */ kind: string; /** - * Optional modifiers for the kind (such as 'public'). - */ + * Optional modifiers for the kind (such as 'public'). + */ kindModifiers?: string; /** - * The definition locations of the item. - */ + * The definition locations of the item. + */ spans: TextSpan[]; /** - * Optional children. - */ + * Optional children. + */ childItems?: NavigationBarItem[]; /** - * Number of levels deep this item should appear. - */ + * Number of levels deep this item should appear. + */ indent: number; } diff --git a/src/server/server.ts b/src/server/server.ts index 4e443add77986..ab746f44f5b72 100644 --- a/src/server/server.ts +++ b/src/server/server.ts @@ -219,6 +219,7 @@ namespace ts.server { host: ServerHost, eventPort: number, readonly globalTypingsCacheLocation: string, + readonly typingSafeListLocation: string, private newLine: string) { this.throttledOperations = new ThrottledOperations(host); if (eventPort) { @@ -260,6 +261,9 @@ namespace ts.server { if (this.logger.loggingEnabled() && this.logger.getLogFileName()) { args.push(Arguments.LogFile, combinePaths(getDirectoryPath(normalizeSlashes(this.logger.getLogFileName())), `ti-${process.pid}.log`)); } + if (this.typingSafeListLocation) { + args.push(Arguments.TypingSafeListLocation, this.typingSafeListLocation); + } const execArgv: string[] = []; { for (const arg of process.execArgv) { @@ -378,11 +382,12 @@ namespace ts.server { useSingleInferredProject: boolean, disableAutomaticTypingAcquisition: boolean, globalTypingsCacheLocation: string, + typingSafeListLocation: string, telemetryEnabled: boolean, logger: server.Logger) { const typingsInstaller = disableAutomaticTypingAcquisition ? undefined - : new NodeTypingsInstaller(telemetryEnabled, logger, host, installerEventPort, globalTypingsCacheLocation, host.newLine); + : new NodeTypingsInstaller(telemetryEnabled, logger, host, installerEventPort, globalTypingsCacheLocation, typingSafeListLocation, host.newLine); super( host, @@ -713,7 +718,7 @@ namespace ts.server { } catch (e) { cancellationToken = nullCancellationToken; - }; + } let eventPort: number; { @@ -729,6 +734,8 @@ namespace ts.server { validateLocaleAndSetLanguage(localeStr, sys); } + const typingSafeListLocation = findArgument("--typingSafeListLocation"); + const useSingleInferredProject = hasArgument("--useSingleInferredProject"); const disableAutomaticTypingAcquisition = hasArgument("--disableAutomaticTypingAcquisition"); const telemetryEnabled = hasArgument(Arguments.EnableTelemetry); @@ -741,6 +748,7 @@ namespace ts.server { useSingleInferredProject, disableAutomaticTypingAcquisition, getGlobalTypingsCacheLocation(), + typingSafeListLocation, telemetryEnabled, logger); process.on("uncaughtException", function (err: Error) { diff --git a/src/server/session.ts b/src/server/session.ts index 11c99dfe46c9e..d01f51cf6c3d0 100644 --- a/src/server/session.ts +++ b/src/server/session.ts @@ -31,7 +31,8 @@ namespace ts.server { } else { // For configured projects, require that skipLibCheck be set also - return project.getCompilerOptions().skipLibCheck && project.isJsOnlyProject(); + const options = project.getCompilerOptions(); + return options.skipLibCheck && !options.checkJs && project.isJsOnlyProject(); } } @@ -218,7 +219,7 @@ namespace ts.server { getCurrentRequestId(): number; sendRequestCompletedEvent(requestId: number): void; getServerHost(): ServerHost; - isCancellationRequested(): boolean; + isCancellationRequested(): boolean; executeWithRequestId(requestId: number, action: () => void): void; logError(error: Error, message: string): void; } @@ -299,7 +300,7 @@ namespace ts.server { } } - private setTimerHandle(timerHandle: any) {; + private setTimerHandle(timerHandle: any) { if (this.timerHandle !== undefined) { this.operationHost.getServerHost().clearTimeout(this.timerHandle); } @@ -337,7 +338,8 @@ namespace ts.server { private hrtime: (start?: number[]) => number[], protected logger: Logger, protected readonly canUseEvents: boolean, - eventHandler?: ProjectServiceEventHandler) { + eventHandler?: ProjectServiceEventHandler, + private readonly throttleWaitMilliseconds?: number) { this.eventHander = canUseEvents ? eventHandler || (event => this.defaultEventHandler(event)) @@ -352,7 +354,7 @@ namespace ts.server { isCancellationRequested: () => cancellationToken.isCancellationRequested() }; this.errorCheck = new MultistepOperation(multistepOperationHost); - this.projectService = new ProjectService(host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, this.eventHander); + this.projectService = new ProjectService(host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, this.eventHander, this.throttleWaitMilliseconds); this.gcTimer = new GcTimer(host, /*delay*/ 7000, logger); } @@ -1018,6 +1020,7 @@ namespace ts.server { if (simplifiedResult) { const displayString = ts.displayPartsToString(quickInfo.displayParts); const docString = ts.displayPartsToString(quickInfo.documentation); + return { kind: quickInfo.kind, kindModifiers: quickInfo.kindModifiers, @@ -1025,6 +1028,7 @@ namespace ts.server { end: scriptInfo.positionToLineOffset(ts.textSpanEnd(quickInfo.textSpan)), displayString: displayString, documentation: docString, + tags: quickInfo.tags || [] }; } else { @@ -1540,17 +1544,17 @@ namespace ts.server { [CommandNames.OpenExternalProject]: (request: protocol.OpenExternalProjectRequest) => { this.projectService.openExternalProject(request.arguments, /*suppressRefreshOfInferredProjects*/ false); // TODO: report errors - return this.requiredResponse(true); + return this.requiredResponse(/*response*/ true); }, [CommandNames.OpenExternalProjects]: (request: protocol.OpenExternalProjectsRequest) => { this.projectService.openExternalProjects(request.arguments.projects); // TODO: report errors - return this.requiredResponse(true); + return this.requiredResponse(/*response*/ true); }, [CommandNames.CloseExternalProject]: (request: protocol.CloseExternalProjectRequest) => { this.projectService.closeExternalProject(request.arguments.projectFileName); // TODO: report errors - return this.requiredResponse(true); + return this.requiredResponse(/*response*/ true); }, [CommandNames.SynchronizeProjectList]: (request: protocol.SynchronizeProjectListRequest) => { const result = this.projectService.synchronizeProjectList(request.arguments.knownProjects); @@ -1574,7 +1578,7 @@ namespace ts.server { this.projectService.applyChangesInOpenFiles(request.arguments.openFiles, request.arguments.changedFiles, request.arguments.closedFiles); this.changeSeq++; // TODO: report errors - return this.requiredResponse(true); + return this.requiredResponse(/*response*/ true); }, [CommandNames.Exit]: () => { this.exit(); @@ -1685,7 +1689,7 @@ namespace ts.server { }, [CommandNames.Cleanup]: () => { this.cleanup(); - return this.requiredResponse(true); + return this.requiredResponse(/*response*/ true); }, [CommandNames.SemanticDiagnosticsSync]: (request: protocol.SemanticDiagnosticsSyncRequest) => { return this.requiredResponse(this.getSemanticDiagnosticsSync(request.arguments)); @@ -1759,7 +1763,7 @@ namespace ts.server { }, [CommandNames.CompilerOptionsForInferredProjects]: (request: protocol.SetCompilerOptionsForInferredProjectsRequest) => { this.setCompilerOptionsForInferredProjects(request.arguments); - return this.requiredResponse(true); + return this.requiredResponse(/*response*/ true); }, [CommandNames.ProjectInfo]: (request: protocol.ProjectInfoRequest) => { return this.requiredResponse(this.getProjectInfo(request.arguments)); diff --git a/src/server/shared.ts b/src/server/shared.ts index 5d65f8c90e98f..6dcf888192727 100644 --- a/src/server/shared.ts +++ b/src/server/shared.ts @@ -11,6 +11,7 @@ namespace ts.server { export const GlobalCacheLocation = "--globalTypingsCacheLocation"; export const LogFile = "--logFile"; export const EnableTelemetry = "--enableTelemetry"; + export const TypingSafeListLocation = "--typingSafeListLocation"; } export function hasArgument(argumentName: string) { diff --git a/src/server/typingsInstaller/nodeTypingsInstaller.ts b/src/server/typingsInstaller/nodeTypingsInstaller.ts index 0a9d8ee29f4af..1018b37d90d29 100644 --- a/src/server/typingsInstaller/nodeTypingsInstaller.ts +++ b/src/server/typingsInstaller/nodeTypingsInstaller.ts @@ -76,11 +76,11 @@ namespace ts.server.typingsInstaller { private delayedInitializationError: InitializationFailedResponse; - constructor(globalTypingsCacheLocation: string, throttleLimit: number, log: Log) { + constructor(globalTypingsCacheLocation: string, typingSafeListLocation: string, throttleLimit: number, log: Log) { super( sys, globalTypingsCacheLocation, - toPath("typingSafeList.json", __dirname, createGetCanonicalFileName(sys.useCaseSensitiveFileNames)), + typingSafeListLocation ? toPath(typingSafeListLocation, "", createGetCanonicalFileName(sys.useCaseSensitiveFileNames)) : toPath("typingSafeList.json", __dirname, createGetCanonicalFileName(sys.useCaseSensitiveFileNames)), throttleLimit, log); if (this.log.isEnabled()) { @@ -164,6 +164,7 @@ namespace ts.server.typingsInstaller { const logFilePath = findArgument(server.Arguments.LogFile); const globalTypingsCacheLocation = findArgument(server.Arguments.GlobalCacheLocation); + const typingSafeListLocation = findArgument(server.Arguments.TypingSafeListLocation); const log = new FileLog(logFilePath); if (log.isEnabled()) { @@ -177,6 +178,6 @@ namespace ts.server.typingsInstaller { } process.exit(0); }); - const installer = new NodeTypingsInstaller(globalTypingsCacheLocation, /*throttleLimit*/5, log); + const installer = new NodeTypingsInstaller(globalTypingsCacheLocation, typingSafeListLocation, /*throttleLimit*/5, log); installer.listen(); } \ No newline at end of file diff --git a/src/server/utilities.ts b/src/server/utilities.ts index af1f8e9826fa7..8784efff7502c 100644 --- a/src/server/utilities.ts +++ b/src/server/utilities.ts @@ -166,11 +166,11 @@ namespace ts.server { export interface ProjectOptions { /** * true if config file explicitly listed files - **/ + */ configHasFilesProperty?: boolean; /** * these fields can be present in the project file - **/ + */ files?: string[]; wildcardDirectories?: Map; compilerOptions?: CompilerOptions; diff --git a/src/services/codefixes/disableJsDiagnostics.ts b/src/services/codefixes/disableJsDiagnostics.ts new file mode 100644 index 0000000000000..7fa5c5bf23ff8 --- /dev/null +++ b/src/services/codefixes/disableJsDiagnostics.ts @@ -0,0 +1,70 @@ +/* @internal */ +namespace ts.codefix { + registerCodeFix({ + errorCodes: getApplicableDiagnosticCodes(), + getCodeActions: getDisableJsDiagnosticsCodeActions + }); + + function getApplicableDiagnosticCodes(): number[] { + const allDiagnostcs = >Diagnostics; + return Object.keys(allDiagnostcs) + .filter(d => allDiagnostcs[d] && allDiagnostcs[d].category === DiagnosticCategory.Error) + .map(d => allDiagnostcs[d].code); + } + + function getIgnoreCommentLocationForLocation(sourceFile: SourceFile, position: number, newLineCharacter: string) { + const { line } = getLineAndCharacterOfPosition(sourceFile, position); + const lineStartPosition = getStartPositionOfLine(line, sourceFile); + const startPosition = getFirstNonSpaceCharacterPosition(sourceFile.text, lineStartPosition); + + // First try to see if we can put the '// @ts-ignore' on the previous line. + // We need to make sure that we are not in the middle of a string literal or a comment. + // We also want to check if the previous line holds a comment for a node on the next line + // if so, we do not want to separate the node from its comment if we can. + if (!isInComment(sourceFile, startPosition) && !isInString(sourceFile, startPosition) && !isInTemplateString(sourceFile, startPosition)) { + const token = getTouchingToken(sourceFile, startPosition); + const tokenLeadingCommnets = getLeadingCommentRangesOfNode(token, sourceFile); + if (!tokenLeadingCommnets || !tokenLeadingCommnets.length || tokenLeadingCommnets[0].pos >= startPosition) { + return { + span: { start: startPosition, length: 0 }, + newText: `// @ts-ignore${newLineCharacter}` + }; + } + } + + // If all fails, add an extra new line immediatlly before the error span. + return { + span: { start: position, length: 0 }, + newText: `${position === startPosition ? "" : newLineCharacter}// @ts-ignore${newLineCharacter}` + }; + } + + function getDisableJsDiagnosticsCodeActions(context: CodeFixContext): CodeAction[] | undefined { + const { sourceFile, program, newLineCharacter, span } = context; + + if (!isInJavaScriptFile(sourceFile) || !isCheckJsEnabledForFile(sourceFile, program.getCompilerOptions())) { + return undefined; + } + + return [{ + description: getLocaleSpecificMessage(Diagnostics.Ignore_this_error_message), + changes: [{ + fileName: sourceFile.fileName, + textChanges: [getIgnoreCommentLocationForLocation(sourceFile, span.start, newLineCharacter)] + }] + }, + { + description: getLocaleSpecificMessage(Diagnostics.Disable_checking_for_this_file), + changes: [{ + fileName: sourceFile.fileName, + textChanges: [{ + span: { + start: sourceFile.checkJsDirective ? sourceFile.checkJsDirective.pos : 0, + length: sourceFile.checkJsDirective ? sourceFile.checkJsDirective.end - sourceFile.checkJsDirective.pos : 0 + }, + newText: `// @ts-nocheck${newLineCharacter}` + }] + }] + }]; + } +} \ No newline at end of file diff --git a/src/services/codefixes/fixAddMissingMember.ts b/src/services/codefixes/fixAddMissingMember.ts index 6ae2ba3f51c99..ec772e1e29e2a 100644 --- a/src/services/codefixes/fixAddMissingMember.ts +++ b/src/services/codefixes/fixAddMissingMember.ts @@ -18,50 +18,121 @@ namespace ts.codefix { return undefined; } - const classDeclaration = getContainingClass(token); - if (!classDeclaration) { + if (!isPropertyAccessExpression(token.parent) || token.parent.expression.kind !== SyntaxKind.ThisKeyword) { return undefined; } - if (!(token.parent && token.parent.kind === SyntaxKind.PropertyAccessExpression)) { + const classMemberDeclaration = getThisContainer(token, /*includeArrowFunctions*/ false); + if (!isClassElement(classMemberDeclaration)) { return undefined; } - if ((token.parent as PropertyAccessExpression).expression.kind !== SyntaxKind.ThisKeyword) { + const classDeclaration = classMemberDeclaration.parent; + if (!classDeclaration || !isClassLike(classDeclaration)) { return undefined; } - let typeString = "any"; + const isStatic = hasModifier(classMemberDeclaration, ModifierFlags.Static); - if (token.parent.parent.kind === SyntaxKind.BinaryExpression) { - const binaryExpression = token.parent.parent as BinaryExpression; + return isInJavaScriptFile(sourceFile) ? getActionsForAddMissingMemberInJavaScriptFile() : getActionsForAddMissingMemberInTypeScriptFile(); - const checker = context.program.getTypeChecker(); - const widenedType = checker.getWidenedType(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(binaryExpression.right))); - typeString = checker.typeToString(widenedType); + function getActionsForAddMissingMemberInJavaScriptFile(): CodeAction[] | undefined { + const memberName = token.getText(); + + if (isStatic) { + if (classDeclaration.kind === SyntaxKind.ClassExpression) { + return undefined; + } + + const className = classDeclaration.name.getText(); + + return [{ + description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Initialize_static_property_0), [memberName]), + changes: [{ + fileName: sourceFile.fileName, + textChanges: [{ + span: { start: classDeclaration.getEnd(), length: 0 }, + newText: `${context.newLineCharacter}${className}.${memberName} = undefined;${context.newLineCharacter}` + }] + }] + }]; + + } + else { + const classConstructor = getFirstConstructorWithBody(classDeclaration); + if (!classConstructor) { + return undefined; + } + + return [{ + description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Initialize_property_0_in_the_constructor), [memberName]), + changes: [{ + fileName: sourceFile.fileName, + textChanges: [{ + span: { start: classConstructor.body.getEnd() - 1, length: 0 }, + newText: `this.${memberName} = undefined;${context.newLineCharacter}` + }] + }] + }]; + } } - const startPos = classDeclaration.members.pos; - - return [{ - description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Add_declaration_for_missing_property_0), [token.getText()]), - changes: [{ - fileName: sourceFile.fileName, - textChanges: [{ - span: { start: startPos, length: 0 }, - newText: `${token.getFullText(sourceFile)}: ${typeString};` - }] - }] - }, - { - description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Add_index_signature_for_missing_property_0), [token.getText()]), - changes: [{ - fileName: sourceFile.fileName, - textChanges: [{ - span: { start: startPos, length: 0 }, - newText: `[name: string]: ${typeString};` - }] - }] - }]; + function getActionsForAddMissingMemberInTypeScriptFile(): CodeAction[] | undefined { + let typeNode: TypeNode; + + if (token.parent.parent.kind === SyntaxKind.BinaryExpression) { + const binaryExpression = token.parent.parent as BinaryExpression; + + const checker = context.program.getTypeChecker(); + const widenedType = checker.getWidenedType(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(binaryExpression.right))); + typeNode = checker.typeToTypeNode(widenedType, classDeclaration); + } + + typeNode = typeNode || createKeywordTypeNode(SyntaxKind.AnyKeyword); + + const openBrace = getOpenBraceOfClassLike(classDeclaration, sourceFile); + + const property = createProperty( + /*decorators*/undefined, + /*modifiers*/ isStatic ? [createToken(SyntaxKind.StaticKeyword)] : undefined, + token.getText(sourceFile), + /*questionToken*/ undefined, + typeNode, + /*initializer*/ undefined); + const propertyChangeTracker = textChanges.ChangeTracker.fromCodeFixContext(context); + propertyChangeTracker.insertNodeAfter(sourceFile, openBrace, property, { suffix: context.newLineCharacter }); + + const actions = [{ + description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Add_declaration_for_missing_property_0), [token.getText()]), + changes: propertyChangeTracker.getChanges() + }]; + + if (!isStatic) { + const stringTypeNode = createKeywordTypeNode(SyntaxKind.StringKeyword); + const indexingParameter = createParameter( + /*decorators*/ undefined, + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, + "x", + /*questionToken*/ undefined, + stringTypeNode, + /*initializer*/ undefined); + const indexSignature = createIndexSignatureDeclaration( + /*decorators*/undefined, + /*modifiers*/ undefined, + [indexingParameter], + typeNode); + + const indexSignatureChangeTracker = textChanges.ChangeTracker.fromCodeFixContext(context); + indexSignatureChangeTracker.insertNodeAfter(sourceFile, openBrace, indexSignature, { suffix: context.newLineCharacter }); + + actions.push({ + description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Add_index_signature_for_missing_property_0), [token.getText()]), + changes: indexSignatureChangeTracker.getChanges() + }); + } + + return actions; + } } } \ No newline at end of file diff --git a/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts b/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts index 16edce0a5166e..62f89b1a21ab5 100644 --- a/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts +++ b/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts @@ -19,10 +19,9 @@ namespace ts.codefix { const checker = context.program.getTypeChecker(); if (isClassLike(token.parent)) { - const classDecl = token.parent as ClassLikeDeclaration; - const startPos = classDecl.members.pos; + const classDeclaration = token.parent as ClassLikeDeclaration; - const extendsNode = getClassExtendsHeritageClauseElement(classDecl); + const extendsNode = getClassExtendsHeritageClauseElement(classDeclaration); const instantiatedExtendsType = checker.getTypeAtLocation(extendsNode); // Note that this is ultimately derived from a map indexed by symbol names, @@ -30,18 +29,12 @@ namespace ts.codefix { const extendsSymbols = checker.getPropertiesOfType(instantiatedExtendsType); const abstractAndNonPrivateExtendsSymbols = extendsSymbols.filter(symbolPointsToNonPrivateAndAbstractMember); - const insertion = getMissingMembersInsertion(classDecl, abstractAndNonPrivateExtendsSymbols, checker, context.newLineCharacter); - - if (insertion.length) { + const newNodes = createMissingMemberNodes(classDeclaration, abstractAndNonPrivateExtendsSymbols, checker); + const changes = newNodesToChanges(newNodes, getOpenBraceOfClassLike(classDeclaration, sourceFile), context); + if (changes && changes.length > 0) { return [{ description: getLocaleSpecificMessage(Diagnostics.Implement_inherited_abstract_class), - changes: [{ - fileName: sourceFile.fileName, - textChanges: [{ - span: { start: startPos, length: 0 }, - newText: insertion - }] - }] + changes }]; } } diff --git a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts index 67b2242c8d97e..3b1b99febb0ea 100644 --- a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts +++ b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts @@ -11,14 +11,14 @@ namespace ts.codefix { const token = getTokenAtPosition(sourceFile, start); const checker = context.program.getTypeChecker(); - const classDecl = getContainingClass(token); - if (!classDecl) { + const classDeclaration = getContainingClass(token); + if (!classDeclaration) { return undefined; } - const startPos: number = classDecl.members.pos; - const classType = checker.getTypeAtLocation(classDecl) as InterfaceType; - const implementedTypeNodes = getClassImplementsHeritageClauseElements(classDecl); + const openBrace = getOpenBraceOfClassLike(classDeclaration, sourceFile); + const classType = checker.getTypeAtLocation(classDeclaration) as InterfaceType; + const implementedTypeNodes = getClassImplementsHeritageClauseElements(classDeclaration); const hasNumericIndexSignature = !!checker.getIndexTypeOfType(classType, IndexKind.Number); const hasStringIndexSignature = !!checker.getIndexTypeOfType(classType, IndexKind.String); @@ -31,43 +31,36 @@ namespace ts.codefix { const implementedTypeSymbols = checker.getPropertiesOfType(implementedType); const nonPrivateMembers = implementedTypeSymbols.filter(symbol => !(getModifierFlags(symbol.valueDeclaration) & ModifierFlags.Private)); - let insertion = getMissingIndexSignatureInsertion(implementedType, IndexKind.Number, classDecl, hasNumericIndexSignature); - insertion += getMissingIndexSignatureInsertion(implementedType, IndexKind.String, classDecl, hasStringIndexSignature); - insertion += getMissingMembersInsertion(classDecl, nonPrivateMembers, checker, context.newLineCharacter); - + let newNodes: Node[] = []; + createAndAddMissingIndexSignatureDeclaration(implementedType, IndexKind.Number, hasNumericIndexSignature, newNodes); + createAndAddMissingIndexSignatureDeclaration(implementedType, IndexKind.String, hasStringIndexSignature, newNodes); + newNodes = newNodes.concat(createMissingMemberNodes(classDeclaration, nonPrivateMembers, checker)); const message = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Implement_interface_0), [implementedTypeNode.getText()]); - if (insertion) { - pushAction(result, insertion, message); + if (newNodes.length > 0) { + pushAction(result, newNodes, message); } } return result; - function getMissingIndexSignatureInsertion(type: InterfaceType, kind: IndexKind, enclosingDeclaration: ClassLikeDeclaration, hasIndexSigOfKind: boolean) { - if (!hasIndexSigOfKind) { - const IndexInfoOfKind = checker.getIndexInfoOfType(type, kind); - if (IndexInfoOfKind) { - const writer = getSingleLineStringWriter(); - checker.getSymbolDisplayBuilder().buildIndexSignatureDisplay(IndexInfoOfKind, writer, kind, enclosingDeclaration); - const result = writer.string(); - releaseStringWriter(writer); + function createAndAddMissingIndexSignatureDeclaration(type: InterfaceType, kind: IndexKind, hasIndexSigOfKind: boolean, newNodes: Node[]): void { + if (hasIndexSigOfKind) { + return; + } + + const indexInfoOfKind = checker.getIndexInfoOfType(type, kind); - return result; - } + if (!indexInfoOfKind) { + return; } - return ""; + const newIndexSignatureDeclaration = checker.indexInfoToIndexSignatureDeclaration(indexInfoOfKind, kind, classDeclaration); + newNodes.push(newIndexSignatureDeclaration); } - function pushAction(result: CodeAction[], insertion: string, description: string): void { + function pushAction(result: CodeAction[], newNodes: Node[], description: string): void { const newAction: CodeAction = { description: description, - changes: [{ - fileName: sourceFile.fileName, - textChanges: [{ - span: { start: startPos, length: 0 }, - newText: insertion - }] - }] + changes: newNodesToChanges(newNodes, openBrace, context) }; result.push(newAction); } diff --git a/src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts b/src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts index 6d7efb64c6fd1..fc2be3cd0c224 100644 --- a/src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts +++ b/src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts @@ -16,7 +16,7 @@ namespace ts.codefix { return undefined; } - // figure out if the this access is actuall inside the supercall + // figure out if the `this` access is actually inside the supercall // i.e. super(this.a), since in that case we won't suggest a fix if (superCall.expression && superCall.expression.kind == SyntaxKind.CallExpression) { const arguments = (superCall.expression).arguments; diff --git a/src/services/codefixes/fixes.ts b/src/services/codefixes/fixes.ts index 76be34c67cda5..ae1643dfa3baa 100644 --- a/src/services/codefixes/fixes.ts +++ b/src/services/codefixes/fixes.ts @@ -7,4 +7,5 @@ /// /// /// +/// /// diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts index d20fc0129cd68..d9e1387e029dc 100644 --- a/src/services/codefixes/helpers.ts +++ b/src/services/codefixes/helpers.ts @@ -1,47 +1,88 @@ /* @internal */ namespace ts.codefix { + export function newNodesToChanges(newNodes: Node[], insertAfter: Node, context: CodeFixContext) { + const sourceFile = context.sourceFile; + + const changeTracker = textChanges.ChangeTracker.fromCodeFixContext(context); + + for (const newNode of newNodes) { + changeTracker.insertNodeAfter(sourceFile, insertAfter, newNode, { suffix: context.newLineCharacter }); + } + + const changes = changeTracker.getChanges(); + if (!some(changes)) { + return changes; + } + + Debug.assert(changes.length === 1); + const consolidatedChanges: FileTextChanges[] = [{ + fileName: changes[0].fileName, + textChanges: [{ + span: changes[0].textChanges[0].span, + newText: changes[0].textChanges.reduce((prev, cur) => prev + cur.newText, "") + }] + + }]; + return consolidatedChanges; + } + /** * Finds members of the resolved type that are missing in the class pointed to by class decl * and generates source code for the missing members. * @param possiblyMissingSymbols The collection of symbols to filter and then get insertions for. * @returns Empty string iff there are no member insertions. */ - export function getMissingMembersInsertion(classDeclaration: ClassLikeDeclaration, possiblyMissingSymbols: Symbol[], checker: TypeChecker, newlineChar: string): string { + export function createMissingMemberNodes(classDeclaration: ClassLikeDeclaration, possiblyMissingSymbols: Symbol[], checker: TypeChecker): Node[] { const classMembers = classDeclaration.symbol.members; const missingMembers = possiblyMissingSymbols.filter(symbol => !classMembers.has(symbol.getName())); - let insertion = ""; - + let newNodes: Node[] = []; for (const symbol of missingMembers) { - insertion = insertion.concat(getInsertionForMemberSymbol(symbol, classDeclaration, checker, newlineChar)); + const newNode = createNewNodeForMemberSymbol(symbol, classDeclaration, checker); + if (newNode) { + if (Array.isArray(newNode)) { + newNodes = newNodes.concat(newNode); + } + else { + newNodes.push(newNode); + } + } } - return insertion; + return newNodes; } /** * @returns Empty string iff there we can't figure out a representation for `symbol` in `enclosingDeclaration`. */ - function getInsertionForMemberSymbol(symbol: Symbol, enclosingDeclaration: ClassLikeDeclaration, checker: TypeChecker, newlineChar: string): string { + function createNewNodeForMemberSymbol(symbol: Symbol, enclosingDeclaration: ClassLikeDeclaration, checker: TypeChecker): Node[] | Node | undefined { const declarations = symbol.getDeclarations(); if (!(declarations && declarations.length)) { - return ""; + return undefined; } const declaration = declarations[0] as Declaration; - const name = declaration.name ? declaration.name.getText() : undefined; - const visibility = getVisibilityPrefixWithSpace(getModifierFlags(declaration)); - - const type = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration); + // Clone name to remove leading trivia. + const name = getSynthesizedClone(declaration.name); + const visibilityModifier = createVisibilityModifier(getModifierFlags(declaration)); + const modifiers = visibilityModifier ? createNodeArray([visibilityModifier]) : undefined; + const type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration)); + const optional = !!(symbol.flags & SymbolFlags.Optional); switch (declaration.kind) { case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: case SyntaxKind.PropertySignature: case SyntaxKind.PropertyDeclaration: - const typeString = checker.typeToString(type, enclosingDeclaration, TypeFormatFlags.None); - return `${visibility}${name}: ${typeString};${newlineChar}`; - + const typeNode = checker.typeToTypeNode(type, enclosingDeclaration); + const property = createProperty( + /*decorators*/undefined, + modifiers, + name, + optional ? createToken(SyntaxKind.QuestionToken) : undefined, + typeNode, + /*initializer*/ undefined); + return property; case SyntaxKind.MethodSignature: case SyntaxKind.MethodDeclaration: // The signature for the implementation appears as an entry in `signatures` iff @@ -52,109 +93,142 @@ namespace ts.codefix { // (eg: an abstract method or interface declaration), there is a 1-1 // correspondence of declarations and signatures. const signatures = checker.getSignaturesOfType(type, SignatureKind.Call); - if (!(signatures && signatures.length > 0)) { - return ""; + if (!some(signatures)) { + return undefined; } + if (declarations.length === 1) { Debug.assert(signatures.length === 1); - const sigString = checker.signatureToString(signatures[0], enclosingDeclaration, TypeFormatFlags.SuppressAnyReturnType, SignatureKind.Call); - return getStubbedMethod(visibility, name, sigString, newlineChar); + const signature = signatures[0]; + return signatureToMethodDeclaration(signature, enclosingDeclaration, createStubbedMethodBody()); } - let result = ""; + const signatureDeclarations: MethodDeclaration[] = []; for (let i = 0; i < signatures.length; i++) { - const sigString = checker.signatureToString(signatures[i], enclosingDeclaration, TypeFormatFlags.SuppressAnyReturnType, SignatureKind.Call); - result += `${visibility}${name}${sigString};${newlineChar}`; + const signature = signatures[i]; + const methodDeclaration = signatureToMethodDeclaration(signature, enclosingDeclaration); + if (methodDeclaration) { + signatureDeclarations.push(methodDeclaration); + } } - // If there is a declaration with a body, it is the last declaration, - // and it isn't caught by `getSignaturesOfType`. - let bodySig: Signature | undefined = undefined; if (declarations.length > signatures.length) { - bodySig = checker.getSignatureFromDeclaration(declarations[declarations.length - 1] as SignatureDeclaration); + const signature = checker.getSignatureFromDeclaration(declarations[declarations.length - 1] as SignatureDeclaration); + const methodDeclaration = signatureToMethodDeclaration(signature, enclosingDeclaration, createStubbedMethodBody()); + if (methodDeclaration) { + signatureDeclarations.push(methodDeclaration); + } } else { Debug.assert(declarations.length === signatures.length); - bodySig = createBodySignatureWithAnyTypes(signatures, enclosingDeclaration, checker); + const methodImplementingSignatures = createMethodImplementingSignatures(signatures, name, optional, modifiers); + signatureDeclarations.push(methodImplementingSignatures); } - const sigString = checker.signatureToString(bodySig, enclosingDeclaration, TypeFormatFlags.SuppressAnyReturnType, SignatureKind.Call); - result += getStubbedMethod(visibility, name, sigString, newlineChar); - - return result; + return signatureDeclarations; default: - return ""; + return undefined; } - } - function createBodySignatureWithAnyTypes(signatures: Signature[], enclosingDeclaration: ClassLikeDeclaration, checker: TypeChecker): Signature { - const newSignatureDeclaration = createNode(SyntaxKind.CallSignature) as SignatureDeclaration; - newSignatureDeclaration.parent = enclosingDeclaration; - newSignatureDeclaration.name = signatures[0].getDeclaration().name; + function signatureToMethodDeclaration(signature: Signature, enclosingDeclaration: Node, body?: Block) { + const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, SyntaxKind.MethodDeclaration, enclosingDeclaration); + if (signatureDeclaration) { + signatureDeclaration.decorators = undefined; + signatureDeclaration.modifiers = modifiers; + signatureDeclaration.name = name; + signatureDeclaration.questionToken = optional ? createToken(SyntaxKind.QuestionToken) : undefined; + signatureDeclaration.body = body; + } + return signatureDeclaration; + } + } - let maxNonRestArgs = -1; - let maxArgsIndex = 0; + function createMethodImplementingSignatures(signatures: Signature[], name: PropertyName, optional: boolean, modifiers: Modifier[] | undefined): MethodDeclaration { + /** This is *a* signature with the maximal number of arguments, + * such that if there is a "maximal" signature without rest arguments, + * this is one of them. + */ + let maxArgsSignature = signatures[0]; let minArgumentCount = signatures[0].minArgumentCount; - let hasRestParameter = false; + let someSigHasRestParameter = false; for (let i = 0; i < signatures.length; i++) { const sig = signatures[i]; minArgumentCount = Math.min(sig.minArgumentCount, minArgumentCount); - hasRestParameter = hasRestParameter || sig.hasRestParameter; - const nonRestLength = sig.parameters.length - (sig.hasRestParameter ? 1 : 0); - if (nonRestLength > maxNonRestArgs) { - maxNonRestArgs = nonRestLength; - maxArgsIndex = i; + if (sig.hasRestParameter) { + someSigHasRestParameter = true; + } + if (sig.parameters.length >= maxArgsSignature.parameters.length && (!sig.hasRestParameter || maxArgsSignature.hasRestParameter)) { + maxArgsSignature = sig; } } - const maxArgsParameterSymbolNames = signatures[maxArgsIndex].getParameters().map(symbol => symbol.getName()); + const maxNonRestArgs = maxArgsSignature.parameters.length - (maxArgsSignature.hasRestParameter ? 1 : 0); + const maxArgsParameterSymbolNames = maxArgsSignature.parameters.map(symbol => symbol.getName()); - const optionalToken = createToken(SyntaxKind.QuestionToken); - - newSignatureDeclaration.parameters = createNodeArray(); + const parameters: ParameterDeclaration[] = []; for (let i = 0; i < maxNonRestArgs; i++) { - const newParameter = createParameterDeclarationWithoutType(i, minArgumentCount, newSignatureDeclaration); - newSignatureDeclaration.parameters.push(newParameter); + const anyType = createKeywordTypeNode(SyntaxKind.AnyKeyword); + const newParameter = createParameter( + /*decorators*/ undefined, + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, + maxArgsParameterSymbolNames[i], + /*questionToken*/ i >= minArgumentCount ? createToken(SyntaxKind.QuestionToken) : undefined, + anyType, + /*initializer*/ undefined); + parameters.push(newParameter); } - if (hasRestParameter) { - const restParameter = createParameterDeclarationWithoutType(maxNonRestArgs, minArgumentCount, newSignatureDeclaration); - restParameter.dotDotDotToken = createToken(SyntaxKind.DotDotDotToken); - newSignatureDeclaration.parameters.push(restParameter); + if (someSigHasRestParameter) { + const anyArrayType = createArrayTypeNode(createKeywordTypeNode(SyntaxKind.AnyKeyword)); + const restParameter = createParameter( + /*decorators*/ undefined, + /*modifiers*/ undefined, + createToken(SyntaxKind.DotDotDotToken), + maxArgsParameterSymbolNames[maxNonRestArgs] || "rest", + /*questionToken*/ maxNonRestArgs >= minArgumentCount ? createToken(SyntaxKind.QuestionToken) : undefined, + anyArrayType, + /*initializer*/ undefined); + parameters.push(restParameter); } - return checker.getSignatureFromDeclaration(newSignatureDeclaration); - - function createParameterDeclarationWithoutType(index: number, minArgCount: number, enclosingSignatureDeclaration: SignatureDeclaration): ParameterDeclaration { - const newParameter = createNode(SyntaxKind.Parameter) as ParameterDeclaration; - - newParameter.symbol = new SymbolConstructor(SymbolFlags.FunctionScopedVariable, maxArgsParameterSymbolNames[index] || "rest"); - newParameter.symbol.valueDeclaration = newParameter; - newParameter.symbol.declarations = [newParameter]; - newParameter.parent = enclosingSignatureDeclaration; - if (index >= minArgCount) { - newParameter.questionToken = optionalToken; - } - - return newParameter; - } + return createStubbedMethod( + modifiers, + name, + optional, + /*typeParameters*/undefined, + parameters, + /*returnType*/ undefined); } - export function getStubbedMethod(visibility: string, name: string, sigString = "()", newlineChar: string): string { - return `${visibility}${name}${sigString}${getMethodBodyStub(newlineChar)}`; + export function createStubbedMethod(modifiers: Modifier[], name: PropertyName, optional: boolean, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], returnType: TypeNode | undefined) { + return createMethodDeclaration( + /*decorators*/ undefined, + modifiers, + /*asteriskToken*/ undefined, + name, + optional ? createToken(SyntaxKind.QuestionToken) : undefined, + typeParameters, + parameters, + returnType, + createStubbedMethodBody()); } - function getMethodBodyStub(newlineChar: string) { - return ` {${newlineChar}throw new Error('Method not implemented.');${newlineChar}}${newlineChar}`; + function createStubbedMethodBody() { + return createBlock( + [createThrow( + createNew( + createIdentifier("Error"), + /*typeArguments*/undefined, + [createLiteral("Method not implemented.")]))], + /*multiline*/true); } - function getVisibilityPrefixWithSpace(flags: ModifierFlags): string { + function createVisibilityModifier(flags: ModifierFlags) { if (flags & ModifierFlags.Public) { - return "public "; + return createToken(SyntaxKind.PublicKeyword); } else if (flags & ModifierFlags.Protected) { - return "protected "; + return createToken(SyntaxKind.ProtectedKeyword); } - return ""; + return undefined; } - - const SymbolConstructor = objectAllocator.getSymbolConstructor(); } \ No newline at end of file diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts index 0c1511ff1ebdb..e10794997cafe 100644 --- a/src/services/codefixes/importFixes.ts +++ b/src/services/codefixes/importFixes.ts @@ -542,12 +542,12 @@ namespace ts.codefix { } function getRelativePathIfInDirectory(path: string, directoryPath: string) { - const relativePath = getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, false); + const relativePath = getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, /*isAbsolutePathAnUrl*/ false); return isRootedDiskPath(relativePath) || startsWith(relativePath, "..") ? undefined : relativePath; } function getRelativePath(path: string, directoryPath: string) { - const relativePath = getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, false); + const relativePath = getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, /*isAbsolutePathAnUrl*/ false); return moduleHasNonRelativeName(relativePath) ? "./" + relativePath : relativePath; } } diff --git a/src/services/completions.ts b/src/services/completions.ts index 738c8b3b8bdff..c0b8be8044169 100644 --- a/src/services/completions.ts +++ b/src/services/completions.ts @@ -173,7 +173,7 @@ namespace ts.Completions { // a['/*completion position*/'] return getStringLiteralCompletionEntriesFromElementAccess(node.parent, typeChecker, compilerOptions.target, log); } - else if (node.parent.kind === SyntaxKind.ImportDeclaration || isExpressionOfExternalModuleImportEqualsDeclaration(node) || isRequireCall(node.parent, false)) { + else if (node.parent.kind === SyntaxKind.ImportDeclaration || isExpressionOfExternalModuleImportEqualsDeclaration(node) || isRequireCall(node.parent, /*checkArgumentIsStringLiteral*/ false)) { // Get all known external module names or complete a path to a module // i.e. import * as ns from "/*completion position*/"; // import x = require("/*completion position*/"); @@ -293,13 +293,14 @@ namespace ts.Completions { const symbol = forEach(symbols, s => getCompletionEntryDisplayNameForSymbol(typeChecker, s, compilerOptions.target, /*performCharacterChecks*/ false, location) === entryName ? s : undefined); if (symbol) { - const { displayParts, documentation, symbolKind } = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, location, location, SemanticMeaning.All); + const { displayParts, documentation, symbolKind, tags } = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, location, location, SemanticMeaning.All); return { name: entryName, kindModifiers: SymbolDisplay.getSymbolModifiers(symbol), kind: symbolKind, displayParts, - documentation + documentation, + tags }; } } @@ -312,7 +313,8 @@ namespace ts.Completions { kind: ScriptElementKind.keyword, kindModifiers: ScriptElementKindModifier.none, displayParts: [displayPart(entryName, SymbolDisplayPartKind.keyword)], - documentation: undefined + documentation: undefined, + tags: undefined }; } diff --git a/src/services/documentRegistry.ts b/src/services/documentRegistry.ts index e2cd20a446352..891a25db76a3c 100644 --- a/src/services/documentRegistry.ts +++ b/src/services/documentRegistry.ts @@ -1,34 +1,34 @@ namespace ts { /** - * The document registry represents a store of SourceFile objects that can be shared between - * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST) - * of files in the context. - * SourceFile objects account for most of the memory usage by the language service. Sharing - * the same DocumentRegistry instance between different instances of LanguageService allow - * for more efficient memory utilization since all projects will share at least the library - * file (lib.d.ts). - * - * A more advanced use of the document registry is to serialize sourceFile objects to disk - * and re-hydrate them when needed. - * - * To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it - * to all subsequent createLanguageService calls. - */ + * The document registry represents a store of SourceFile objects that can be shared between + * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST) + * of files in the context. + * SourceFile objects account for most of the memory usage by the language service. Sharing + * the same DocumentRegistry instance between different instances of LanguageService allow + * for more efficient memory utilization since all projects will share at least the library + * file (lib.d.ts). + * + * A more advanced use of the document registry is to serialize sourceFile objects to disk + * and re-hydrate them when needed. + * + * To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it + * to all subsequent createLanguageService calls. + */ export interface DocumentRegistry { /** - * Request a stored SourceFile with a given fileName and compilationSettings. - * The first call to acquire will call createLanguageServiceSourceFile to generate - * the SourceFile if was not found in the registry. - * - * @param fileName The name of the file requested - * @param compilationSettings Some compilation settings like target affects the - * shape of a the resulting SourceFile. This allows the DocumentRegistry to store - * multiple copies of the same file for different compilation settings. - * @parm scriptSnapshot Text of the file. Only used if the file was not found - * in the registry and a new one was created. - * @parm version Current version of the file. Only used if the file was not found - * in the registry and a new one was created. - */ + * Request a stored SourceFile with a given fileName and compilationSettings. + * The first call to acquire will call createLanguageServiceSourceFile to generate + * the SourceFile if was not found in the registry. + * + * @param fileName The name of the file requested + * @param compilationSettings Some compilation settings like target affects the + * shape of a the resulting SourceFile. This allows the DocumentRegistry to store + * multiple copies of the same file for different compilation settings. + * @parm scriptSnapshot Text of the file. Only used if the file was not found + * in the registry and a new one was created. + * @parm version Current version of the file. Only used if the file was not found + * in the registry and a new one was created. + */ acquireDocument( fileName: string, compilationSettings: CompilerOptions, @@ -46,17 +46,17 @@ namespace ts { scriptKind?: ScriptKind): SourceFile; /** - * Request an updated version of an already existing SourceFile with a given fileName - * and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile - * to get an updated SourceFile. - * - * @param fileName The name of the file requested - * @param compilationSettings Some compilation settings like target affects the - * shape of a the resulting SourceFile. This allows the DocumentRegistry to store - * multiple copies of the same file for different compilation settings. - * @param scriptSnapshot Text of the file. - * @param version Current version of the file. - */ + * Request an updated version of an already existing SourceFile with a given fileName + * and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile + * to get an updated SourceFile. + * + * @param fileName The name of the file requested + * @param compilationSettings Some compilation settings like target affects the + * shape of a the resulting SourceFile. This allows the DocumentRegistry to store + * multiple copies of the same file for different compilation settings. + * @param scriptSnapshot Text of the file. + * @param version Current version of the file. + */ updateDocument( fileName: string, compilationSettings: CompilerOptions, @@ -75,14 +75,14 @@ namespace ts { getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey; /** - * Informs the DocumentRegistry that a file is not needed any longer. - * - * Note: It is not allowed to call release on a SourceFile that was not acquired from - * this registry originally. - * - * @param fileName The name of the file to be released - * @param compilationSettings The compilation settings used to acquire the file - */ + * Informs the DocumentRegistry that a file is not needed any longer. + * + * Note: It is not allowed to call release on a SourceFile that was not acquired from + * this registry originally. + * + * @param fileName The name of the file to be released + * @param compilationSettings The compilation settings used to acquire the file + */ releaseDocument(fileName: string, compilationSettings: CompilerOptions): void; releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey): void; diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index 5a471fb6f356c..caa68470b884d 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -187,7 +187,7 @@ namespace ts.FindAllReferences { return { symbol }; } - if (ts.isUntypedOrShorthandAmbientModuleSymbol(aliasedSymbol)) { + if (ts.isShorthandAmbientModuleSymbol(aliasedSymbol)) { return { symbol, shorthandModuleSymbol: aliasedSymbol }; } @@ -496,9 +496,9 @@ namespace ts.FindAllReferences { } /** Search within node "container" for references for a search value, where the search value is defined as a - * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning). - * searchLocation: a node where the search value - */ + * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning). + * searchLocation: a node where the search value + */ function getReferencesInNode(container: Node, searchSymbol: Symbol, searchText: string, @@ -701,7 +701,7 @@ namespace ts.FindAllReferences { } }); } - }; + } return result; } diff --git a/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts index 4fa3b71a3a200..51b49a70d31b9 100644 --- a/src/services/formatting/formatting.ts +++ b/src/services/formatting/formatting.ts @@ -34,31 +34,31 @@ namespace ts.formatting { getIndentationForToken(tokenLine: number, tokenKind: SyntaxKind, container: Node): number; getIndentationForComment(owningToken: SyntaxKind, tokenIndentation: number, container: Node): number; /** - * Indentation for open and close tokens of the node if it is block or another node that needs special indentation - * ... { - * ......... - * ....} - * ____ - indentation - * ____ - delta - **/ + * Indentation for open and close tokens of the node if it is block or another node that needs special indentation + * ... { + * ......... + * ....} + * ____ - indentation + * ____ - delta + */ getIndentation(): number; /** - * Prefered relative indentation for child nodes. - * Delta is used to carry the indentation info - * foo(bar({ - * $ - * })) - * Both 'foo', 'bar' introduce new indentation with delta = 4, but total indentation in $ is not 8. - * foo: { indentation: 0, delta: 4 } - * bar: { indentation: foo.indentation + foo.delta = 4, delta: 4} however 'foo' and 'bar' are on the same line - * so bar inherits indentation from foo and bar.delta will be 4 - * - */ + * Prefered relative indentation for child nodes. + * Delta is used to carry the indentation info + * foo(bar({ + * $ + * })) + * Both 'foo', 'bar' introduce new indentation with delta = 4, but total indentation in $ is not 8. + * foo: { indentation: 0, delta: 4 } + * bar: { indentation: foo.indentation + foo.delta = 4, delta: 4} however 'foo' and 'bar' are on the same line + * so bar inherits indentation from foo and bar.delta will be 4 + * + */ getDelta(child: TextRangeWithKind): number; /** - * Formatter calls this function when rule adds or deletes new lines from the text - * so indentation scope can adjust values of indentation and delta. - */ + * Formatter calls this function when rule adds or deletes new lines from the text + * so indentation scope can adjust values of indentation and delta. + */ recomputeIndentation(lineAddedByFormatting: boolean): void; } @@ -205,9 +205,9 @@ namespace ts.formatting { } /** formatting is not applied to ranges that contain parse errors. - * This function will return a predicate that for a given text range will tell - * if there are any parse errors that overlap with the range. - */ + * This function will return a predicate that for a given text range will tell + * if there are any parse errors that overlap with the range. + */ function prepareRangeContainsErrorFunction(errors: Diagnostic[], originalRange: TextRange): (r: TextRange) => boolean { if (!errors.length) { return rangeHasNoErrors; @@ -254,10 +254,10 @@ namespace ts.formatting { } /** - * Start of the original range might fall inside the comment - scanner will not yield appropriate results - * This function will look for token that is located before the start of target range - * and return its end as start position for the scanner. - */ + * Start of the original range might fall inside the comment - scanner will not yield appropriate results + * This function will look for token that is located before the start of target range + * and return its end as start position for the scanner. + */ function getScanStartPosition(enclosingNode: Node, originalRange: TextRange, sourceFile: SourceFile): number { const start = enclosingNode.getStart(sourceFile); if (start === originalRange.pos && enclosingNode.end === originalRange.end) { @@ -400,12 +400,12 @@ namespace ts.formatting { // local functions /** Tries to compute the indentation for a list element. - * If list element is not in range then - * function will pick its actual indentation - * so it can be pushed downstream as inherited indentation. - * If list element is in the range - its indentation will be equal - * to inherited indentation from its predecessors. - */ + * If list element is not in range then + * function will pick its actual indentation + * so it can be pushed downstream as inherited indentation. + * If list element is in the range - its indentation will be equal + * to inherited indentation from its predecessors. + */ function tryComputeIndentationForListItem(startPos: number, endPos: number, parentStartLine: number, @@ -568,7 +568,7 @@ namespace ts.formatting { function getEffectiveDelta(delta: number, child: TextRangeWithKind) { // Delta value should be zero when the node explicitly prevents indentation of the child node - return SmartIndenter.nodeWillIndentChild(node, child, true) ? delta : 0; + return SmartIndenter.nodeWillIndentChild(node, child, /*indentByDefault*/ true) ? delta : 0; } } diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index b182b8e01f394..fb99a2a4675ee 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -297,8 +297,8 @@ namespace ts.formatting { // Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}. this.SpaceAfterOpenBrace = new Rule(RuleDescriptor.create3(SyntaxKind.OpenBraceToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsBraceWrappedContext), RuleAction.Space)); this.SpaceBeforeCloseBrace = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsBraceWrappedContext), RuleAction.Space)); - this.NoSpaceAfterOpenBrace = new Rule(RuleDescriptor.create3(SyntaxKind.OpenBraceToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsBraceWrappedContext), RuleAction.Delete)); - this.NoSpaceBeforeCloseBrace = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsBraceWrappedContext), RuleAction.Delete)); + this.NoSpaceAfterOpenBrace = new Rule(RuleDescriptor.create3(SyntaxKind.OpenBraceToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete)); + this.NoSpaceBeforeCloseBrace = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete)); this.NoSpaceBetweenEmptyBraceBrackets = new Rule(RuleDescriptor.create1(SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsObjectContext), RuleAction.Delete)); // Insert new line after { and before } in multi-line contexts. diff --git a/src/services/jsDoc.ts b/src/services/jsDoc.ts index d993facbb1d9e..37c22b4352cea 100644 --- a/src/services/jsDoc.ts +++ b/src/services/jsDoc.ts @@ -70,6 +70,28 @@ namespace ts.JsDoc { return documentationComment; } + export function getJsDocTagsFromDeclarations(declarations: Declaration[]) { + // Only collect doc comments from duplicate declarations once. + const tags: JSDocTagInfo[] = []; + forEachUnique(declarations, declaration => { + const jsDocs = getJSDocs(declaration); + if (!jsDocs) { + return; + } + for (const doc of jsDocs) { + const tagsForDoc = (doc as JSDoc).tags; + if (tagsForDoc) { + tags.push(...tagsForDoc.filter(tag => tag.kind === SyntaxKind.JSDocTag).map(jsDocTag => { + return { + name: jsDocTag.tagName.text, + text: jsDocTag.comment + }; })); + } + } + }); + return tags; + } + /** * Iterates through 'array' by index and performs the callback on each element of array until the callback * returns a truthy value, then returns that value. diff --git a/src/services/jsTyping.ts b/src/services/jsTyping.ts index e7196e8f491c5..f601c9604de24 100644 --- a/src/services/jsTyping.ts +++ b/src/services/jsTyping.ts @@ -13,7 +13,7 @@ namespace ts.JsTyping { fileExists: (fileName: string) => boolean; readFile: (path: string, encoding?: string) => string; readDirectory: (rootDir: string, extensions: string[], excludes: string[], includes: string[], depth?: number) => string[]; - }; + } interface PackageJson { _requiredBy?: string[]; @@ -23,7 +23,7 @@ namespace ts.JsTyping { optionalDependencies?: MapLike; peerDependencies?: MapLike; typings?: string; - }; + } // A map of loose file names to library names // that we are confident require typings @@ -99,8 +99,11 @@ namespace ts.JsTyping { const bowerJsonPath = combinePaths(searchDir, "bower.json"); getTypingNamesFromJson(bowerJsonPath, filesToWatch); + const bowerComponentsPath = combinePaths(searchDir, "bower_components"); + getTypingNamesFromPackagesFolder(bowerComponentsPath); + const nodeModulesPath = combinePaths(searchDir, "node_modules"); - getTypingNamesFromNodeModuleFolder(nodeModulesPath); + getTypingNamesFromPackagesFolder(nodeModulesPath); } getTypingNamesFromSourceFileNames(fileNames); @@ -199,20 +202,23 @@ namespace ts.JsTyping { } /** - * Infer typing names from node_module folder - * @param nodeModulesPath is the path to the "node_modules" folder + * Infer typing names from packages folder (ex: node_module, bower_components) + * @param packagesFolderPath is the path to the packages folder */ - function getTypingNamesFromNodeModuleFolder(nodeModulesPath: string) { + function getTypingNamesFromPackagesFolder(packagesFolderPath: string) { + filesToWatch.push(packagesFolderPath); + // Todo: add support for ModuleResolutionHost too - if (!host.directoryExists(nodeModulesPath)) { + if (!host.directoryExists(packagesFolderPath)) { return; } const typingNames: string[] = []; - const fileNames = host.readDirectory(nodeModulesPath, [".json"], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 2); + const fileNames = host.readDirectory(packagesFolderPath, [".json"], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 2); for (const fileName of fileNames) { const normalizedFileName = normalizePath(fileName); - if (getBaseFileName(normalizedFileName) !== "package.json") { + const baseFileName = getBaseFileName(normalizedFileName); + if (baseFileName !== "package.json" && baseFileName !== "bower.json") { continue; } const result = readConfigFile(normalizedFileName, (path: string) => host.readFile(path)); @@ -224,7 +230,7 @@ namespace ts.JsTyping { // npm 3's package.json contains a "_requiredBy" field // we should include all the top level module names for npm 2, and only module names whose // "_requiredBy" field starts with "#" or equals "/" for npm 3. - if (packageJson._requiredBy && + if (baseFileName === "package.json" && packageJson._requiredBy && filter(packageJson._requiredBy, (r: string) => r[0] === "#" || r === "/").length === 0) { continue; } diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts index 25059d1f57d4a..7a2508fcfd66c 100644 --- a/src/services/navigationBar.ts +++ b/src/services/navigationBar.ts @@ -2,6 +2,36 @@ /* @internal */ namespace ts.NavigationBar { + /** + * Matches all whitespace characters in a string. Eg: + * + * "app. + * + * onactivated" + * + * matches because of the newline, whereas + * + * "app.onactivated" + * + * does not match. + */ + const whiteSpaceRegex = /\s+/g; + + // Keep sourceFile handy so we don't have to search for it every time we need to call `getText`. + let curCancellationToken: CancellationToken; + let curSourceFile: SourceFile; + + /** + * For performance, we keep navigation bar parents on a stack rather than passing them through each recursion. + * `parent` is the current parent and is *not* stored in parentsStack. + * `startNode` sets a new parent and `endNode` returns to the previous parent. + */ + let parentsStack: NavigationBarNode[] = []; + let parent: NavigationBarNode; + + // NavigationBarItem requires an array, but will not mutate it, so just give it this for performance. + let emptyChildItemArray: NavigationBarItem[] = []; + /** * Represents a navigation bar item and its children. * The returned NavigationBarItem is more complicated and doesn't include 'parent', so we use these to do work before converting. @@ -14,22 +44,36 @@ namespace ts.NavigationBar { indent: number; // # of parents } - export function getNavigationBarItems(sourceFile: SourceFile): NavigationBarItem[] { + export function getNavigationBarItems(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationBarItem[] { + curCancellationToken = cancellationToken; curSourceFile = sourceFile; - const result = map(topLevelItems(rootNavigationBarNode(sourceFile)), convertToTopLevelItem); - curSourceFile = undefined; - return result; + try { + return map(topLevelItems(rootNavigationBarNode(sourceFile)), convertToTopLevelItem); + } + finally { + reset(); + } } - export function getNavigationTree(sourceFile: SourceFile): NavigationTree { + export function getNavigationTree(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationTree { + curCancellationToken = cancellationToken; curSourceFile = sourceFile; - const result = convertToTree(rootNavigationBarNode(sourceFile)); + try { + return convertToTree(rootNavigationBarNode(sourceFile)); + } + finally { + reset(); + } + } + + function reset() { curSourceFile = undefined; - return result; + curCancellationToken = undefined; + parentsStack = []; + parent = undefined; + emptyChildItemArray = []; } - // Keep sourceFile handy so we don't have to search for it every time we need to call `getText`. - let curSourceFile: SourceFile; function nodeText(node: Node): string { return node.getText(curSourceFile); } @@ -47,14 +91,6 @@ namespace ts.NavigationBar { } } - /* - For performance, we keep navigation bar parents on a stack rather than passing them through each recursion. - `parent` is the current parent and is *not* stored in parentsStack. - `startNode` sets a new parent and `endNode` returns to the previous parent. - */ - const parentsStack: NavigationBarNode[] = []; - let parent: NavigationBarNode; - function rootNavigationBarNode(sourceFile: SourceFile): NavigationBarNode { Debug.assert(!parentsStack.length); const root: NavigationBarNode = { node: sourceFile, additionalNodes: undefined, parent: undefined, children: undefined, indent: 0 }; @@ -111,6 +147,8 @@ namespace ts.NavigationBar { /** Look for navigation bar items in node's subtree, adding them to the current `parent`. */ function addChildrenRecursively(node: Node): void { + curCancellationToken.throwIfCancellationRequested(); + if (!node || isToken(node)) { return; } @@ -487,9 +525,6 @@ namespace ts.NavigationBar { } } - // NavigationBarItem requires an array, but will not mutate it, so just give it this for performance. - const emptyChildItemArray: NavigationBarItem[] = []; - function convertToTree(n: NavigationBarNode): NavigationTree { return { text: getItemName(n.node), @@ -610,19 +645,4 @@ namespace ts.NavigationBar { function isFunctionOrClassExpression(node: Node): boolean { return node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.ArrowFunction || node.kind === SyntaxKind.ClassExpression; } - - /** - * Matches all whitespace characters in a string. Eg: - * - * "app. - * - * onactivated" - * - * matches because of the newline, whereas - * - * "app.onactivated" - * - * does not match. - */ - const whiteSpaceRegex = /\s+/g; } diff --git a/src/services/outliningElementsCollector.ts b/src/services/outliningElementsCollector.ts index 43054a10f5d39..510f78c3f3957 100644 --- a/src/services/outliningElementsCollector.ts +++ b/src/services/outliningElementsCollector.ts @@ -1,6 +1,6 @@ /* @internal */ namespace ts.OutliningElementsCollector { - export function collectElements(sourceFile: SourceFile): OutliningSpan[] { + export function collectElements(sourceFile: SourceFile, cancellationToken: CancellationToken): OutliningSpan[] { const elements: OutliningSpan[] = []; const collapseText = "..."; @@ -38,6 +38,7 @@ namespace ts.OutliningElementsCollector { let singleLineCommentCount = 0; for (const currentComment of comments) { + cancellationToken.throwIfCancellationRequested(); // For single line comments, combine consecutive ones (2 or more) into // a single span from the start of the first till the end of the last @@ -84,6 +85,7 @@ namespace ts.OutliningElementsCollector { let depth = 0; const maxDepth = 20; function walk(n: Node): void { + cancellationToken.throwIfCancellationRequested(); if (depth > maxDepth) { return; } diff --git a/src/services/services.ts b/src/services/services.ts index d8a4cbeae675a..3d108ac7fab93 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -302,6 +302,10 @@ namespace ts { // symbol has no doc comment, then the empty string will be returned. documentationComment: SymbolDisplayPart[]; + // Undefined is used to indicate the value has not been computed. If, after computing, the + // symbol has no JSDoc tags, then the empty array will be returned. + tags: JSDocTagInfo[]; + constructor(flags: SymbolFlags, name: string) { this.flags = flags; this.name = name; @@ -326,6 +330,14 @@ namespace ts { return this.documentationComment; } + + getJsDocTags(): JSDocTagInfo[] { + if (this.tags === undefined) { + this.tags = JsDoc.getJsDocTagsFromDeclarations(this.declarations); + } + + return this.tags; + } } class TokenObject extends TokenOrIdentifierObject implements Token { @@ -415,6 +427,10 @@ namespace ts { // symbol has no doc comment, then the empty string will be returned. documentationComment: SymbolDisplayPart[]; + // Undefined is used to indicate the value has not been computed. If, after computing, the + // symbol has no doc comment, then the empty array will be returned. + jsDocTags: JSDocTagInfo[]; + constructor(checker: TypeChecker) { this.checker = checker; } @@ -438,6 +454,14 @@ namespace ts { return this.documentationComment; } + + getJsDocTags(): JSDocTagInfo[] { + if (this.jsDocTags === undefined) { + this.jsDocTags = this.declaration ? JsDoc.getJsDocTagsFromDeclarations([this.declaration]) : []; + } + + return this.jsDocTags; + } } class SourceFileObject extends NodeObject implements SourceFile { @@ -482,6 +506,7 @@ namespace ts { public moduleAugmentations: LiteralExpression[]; private namedDeclarations: Map; public ambientModuleNames: string[]; + public checkJsDirective: CheckJsDirective | undefined; constructor(kind: SyntaxKind, pos: number, end: number) { super(kind, pos, end); @@ -981,6 +1006,36 @@ namespace ts { } } + /* @internal */ + /** A cancellation that throttles calls to the host */ + export class ThrottledCancellationToken implements CancellationToken { + // Store when we last tried to cancel. Checking cancellation can be expensive (as we have + // to marshall over to the host layer). So we only bother actually checking once enough + // time has passed. + private lastCancellationCheckTime = 0; + + constructor(private hostCancellationToken: HostCancellationToken, private readonly throttleWaitMilliseconds = 20) { + } + + public isCancellationRequested(): boolean { + const time = timestamp(); + const duration = Math.abs(time - this.lastCancellationCheckTime); + if (duration >= this.throttleWaitMilliseconds) { + // Check no more than once every throttle wait milliseconds + this.lastCancellationCheckTime = time; + return this.hostCancellationToken.isCancellationRequested(); + } + + return false; + } + + public throwIfCancellationRequested(): void { + if (this.isCancellationRequested()) { + throw new OperationCanceledException(); + } + } + } + export function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory())): LanguageService { @@ -1329,7 +1384,8 @@ namespace ts { kindModifiers: ScriptElementKindModifier.none, textSpan: createTextSpan(node.getStart(), node.getWidth()), displayParts: typeToDisplayParts(typeChecker, type, getContainerNode(node)), - documentation: type.symbol ? type.symbol.getDocumentationComment() : undefined + documentation: type.symbol ? type.symbol.getDocumentationComment() : undefined, + tags: type.symbol ? type.symbol.getJsDocTags() : undefined }; } } @@ -1343,7 +1399,8 @@ namespace ts { kindModifiers: SymbolDisplay.getSymbolModifiers(symbol), textSpan: createTextSpan(node.getStart(), node.getWidth()), displayParts: displayPartsDocumentationsAndKind.displayParts, - documentation: displayPartsDocumentationsAndKind.documentation + documentation: displayPartsDocumentationsAndKind.documentation, + tags: displayPartsDocumentationsAndKind.tags }; } @@ -1552,11 +1609,11 @@ namespace ts { } function getNavigationBarItems(fileName: string): NavigationBarItem[] { - return NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName)); + return NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); } function getNavigationTree(fileName: string): NavigationTree { - return NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName)); + return NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); } function isTsOrTsxFile(fileName: string): boolean { @@ -1595,7 +1652,7 @@ namespace ts { function getOutliningSpans(fileName: string): OutliningSpan[] { // doesn't use compiler - no need to synchronize with host const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - return OutliningElementsCollector.collectElements(sourceFile); + return OutliningElementsCollector.collectElements(sourceFile, cancellationToken); } function getBraceMatchingAtPosition(fileName: string, position: number) { @@ -2074,10 +2131,10 @@ namespace ts { declare const __dirname: string; /** - * Get the path of the default library files (lib.d.ts) as distributed with the typescript - * node package. - * The functionality is not supported if the ts module is consumed outside of a node module. - */ + * Get the path of the default library files (lib.d.ts) as distributed with the typescript + * node package. + * The functionality is not supported if the ts module is consumed outside of a node module. + */ export function getDefaultLibFilePath(options: CompilerOptions): string { // Check __dirname is defined and that we are on a node.js system. if (typeof __dirname !== "undefined") { diff --git a/src/services/shims.ts b/src/services/shims.ts index 6fe9aed144e7c..37b3fbc3d9434 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -49,7 +49,7 @@ namespace ts { error(s: string): void; } - /** Public interface of the host of a language service shim instance.*/ + /** Public interface of the host of a language service shim instance. */ export interface LanguageServiceShimHost extends Logger { getCompilationSettings(): string; @@ -469,29 +469,6 @@ namespace ts { } } - /** A cancellation that throttles calls to the host */ - class ThrottledCancellationToken implements HostCancellationToken { - // Store when we last tried to cancel. Checking cancellation can be expensive (as we have - // to marshall over to the host layer). So we only bother actually checking once enough - // time has passed. - private lastCancellationCheckTime = 0; - - constructor(private hostCancellationToken: HostCancellationToken) { - } - - public isCancellationRequested(): boolean { - const time = timestamp(); - const duration = Math.abs(time - this.lastCancellationCheckTime); - if (duration > 10) { - // Check no more than once every 10 ms. - this.lastCancellationCheckTime = time; - return this.hostCancellationToken.isCancellationRequested(); - } - - return false; - } - } - export class CoreServicesShimHostAdapter implements ParseConfigHost, ModuleResolutionHost { public directoryExists: (directoryName: string) => boolean; @@ -1249,7 +1226,7 @@ namespace ts { // Here we expose the TypeScript services as an external module // so that it may be consumed easily like a node module. - declare var module: any; + declare const module: any; if (typeof module !== "undefined" && module.exports) { module.exports = ts; } diff --git a/src/services/signatureHelp.ts b/src/services/signatureHelp.ts index 3b22fcef9567b..7b2abc6123c90 100644 --- a/src/services/signatureHelp.ts +++ b/src/services/signatureHelp.ts @@ -606,7 +606,8 @@ namespace ts.SignatureHelp { suffixDisplayParts, separatorDisplayParts: [punctuationPart(SyntaxKind.CommaToken), spacePart()], parameters: signatureHelpParameters, - documentation: candidateSignature.getDocumentationComment() + documentation: candidateSignature.getDocumentationComment(), + tags: candidateSignature.getJsDocTags() }; }); diff --git a/src/services/symbolDisplay.ts b/src/services/symbolDisplay.ts index b457165b67f70..41bdf4d8ada13 100644 --- a/src/services/symbolDisplay.ts +++ b/src/services/symbolDisplay.ts @@ -93,6 +93,7 @@ namespace ts.SymbolDisplay { const displayParts: SymbolDisplayPart[] = []; let documentation: SymbolDisplayPart[]; + let tags: JSDocTagInfo[]; const symbolFlags = symbol.flags; let symbolKind = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location); let hasAddedSymbolInfo: boolean; @@ -418,8 +419,9 @@ namespace ts.SymbolDisplay { if (!documentation) { documentation = symbol.getDocumentationComment(); + tags = symbol.getJsDocTags(); if (documentation.length === 0 && symbol.flags & SymbolFlags.Property) { - // For some special property access expressions like `experts.foo = foo` or `module.exports.foo = foo` + // For some special property access expressions like `exports.foo = foo` or `module.exports.foo = foo` // there documentation comments might be attached to the right hand side symbol of their declarations. // The pattern of such special property access is that the parent symbol is the symbol of the file. if (symbol.parent && forEach(symbol.parent.declarations, declaration => declaration.kind === SyntaxKind.SourceFile)) { @@ -434,6 +436,7 @@ namespace ts.SymbolDisplay { } documentation = rhsSymbol.getDocumentationComment(); + tags = rhsSymbol.getJsDocTags(); if (documentation.length > 0) { break; } @@ -442,7 +445,7 @@ namespace ts.SymbolDisplay { } } - return { displayParts, documentation, symbolKind }; + return { displayParts, documentation, symbolKind, tags }; function addNewLineIfDisplayPartsExist() { if (displayParts.length) { @@ -500,6 +503,7 @@ namespace ts.SymbolDisplay { displayParts.push(punctuationPart(SyntaxKind.CloseParenToken)); } documentation = signature.getDocumentationComment(); + tags = signature.getJsDocTags(); } function writeTypeParametersOfSymbol(symbol: Symbol, enclosingDeclaration: Node) { diff --git a/src/services/textChanges.ts b/src/services/textChanges.ts index 424399db72ee6..d7056cfdca241 100644 --- a/src/services/textChanges.ts +++ b/src/services/textChanges.ts @@ -274,9 +274,9 @@ namespace ts.textChanges { } /** - * This function should be used to insert nodes in lists when nodes don't carry separators as the part of the node range, - * i.e. arguments in arguments lists, parameters in parameter lists etc. Statements or class elements are different in sense that - * for them separators are treated as the part of the node. + * This function should be used to insert nodes in lists when nodes don't carry separators as the part of the node range, + * i.e. arguments in arguments lists, parameters in parameter lists etc. + * Note that separators are part of the node in statements and class elements. */ public insertNodeInListAfter(sourceFile: SourceFile, after: Node, newNode: Node) { const containingList = formatting.SmartIndenter.getContainingList(after, sourceFile); @@ -421,7 +421,7 @@ namespace ts.textChanges { let changesInFile = changesPerFile.get(c.sourceFile.path); if (!changesInFile) { changesPerFile.set(c.sourceFile.path, changesInFile = []); - }; + } changesInFile.push(c); } // convert changes @@ -484,7 +484,7 @@ namespace ts.textChanges { private static normalize(changes: Change[]) { // order changes by start position const normalized = stableSort(changes, (a, b) => a.range.pos - b.range.pos); - // verify that end position of the change is less than start position of the next change + // verify that change intervals do not overlap, except possibly at end points. for (let i = 0; i < normalized.length - 2; i++) { Debug.assert(normalized[i].range.end <= normalized[i + 1].range.pos); } @@ -549,7 +549,7 @@ namespace ts.textChanges { }; function assignPositionsToNode(node: Node): Node { - const visited = visitEachChild(node, assignPositionsToNode, nullTransformationContext, assignPositionsToNodeArray); + const visited = visitEachChild(node, assignPositionsToNode, nullTransformationContext, assignPositionsToNodeArray, assignPositionsToNode); // create proxy node for non synthesized nodes const newNode = nodeIsSynthesized(visited) ? visited diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json index b1391bd7300a5..6b40c71e20488 100644 --- a/src/services/tsconfig.json +++ b/src/services/tsconfig.json @@ -91,6 +91,7 @@ "codefixes/fixes.ts", "codefixes/helpers.ts", "codefixes/importFixes.ts", - "codefixes/unusedIdentifierFixes.ts" + "codefixes/unusedIdentifierFixes.ts", + "codefixes/disableJsDiagnostics.ts" ] } \ No newline at end of file diff --git a/src/services/types.ts b/src/services/types.ts index 05ec81a419756..62fbf18cddf3e 100644 --- a/src/services/types.ts +++ b/src/services/types.ts @@ -27,6 +27,7 @@ namespace ts { getName(): string; getDeclarations(): Declaration[]; getDocumentationComment(): SymbolDisplayPart[]; + getJsDocTags(): JSDocTagInfo[]; } export interface Type { @@ -49,6 +50,7 @@ namespace ts { getParameters(): Symbol[]; getReturnType(): Type; getDocumentationComment(): SymbolDisplayPart[]; + getJsDocTags(): JSDocTagInfo[]; } export interface SourceFile { @@ -519,12 +521,18 @@ namespace ts { kind: string; // A ScriptElementKind } + export interface JSDocTagInfo { + name: string; + text?: string; + } + export interface QuickInfo { kind: string; kindModifiers: string; textSpan: TextSpan; displayParts: SymbolDisplayPart[]; documentation: SymbolDisplayPart[]; + tags: JSDocTagInfo[]; } export interface RenameInfo { @@ -558,6 +566,7 @@ namespace ts { separatorDisplayParts: SymbolDisplayPart[]; parameters: SignatureHelpParameter[]; documentation: SymbolDisplayPart[]; + tags: JSDocTagInfo[]; } /** @@ -588,10 +597,10 @@ namespace ts { kindModifiers: string; // see ScriptElementKindModifier, comma separated sortText: string; /** - * An optional span that indicates the text to be replaced by this completion item. It will be - * set if the required span differs from the one generated by the default replacement behavior and should - * be used in that case - */ + * An optional span that indicates the text to be replaced by this completion item. It will be + * set if the required span differs from the one generated by the default replacement behavior and should + * be used in that case + */ replacementSpan?: TextSpan; } @@ -601,6 +610,7 @@ namespace ts { kindModifiers: string; // see ScriptElementKindModifier, comma separated displayParts: SymbolDisplayPart[]; documentation: SymbolDisplayPart[]; + tags: JSDocTagInfo[]; } export interface OutliningSpan { @@ -614,9 +624,9 @@ namespace ts { bannerText: string; /** - * Whether or not this region should be automatically collapsed when - * the 'Collapse to Definitions' command is invoked. - */ + * Whether or not this region should be automatically collapsed when + * the 'Collapse to Definitions' command is invoked. + */ autoCollapse: boolean; } @@ -788,7 +798,7 @@ namespace ts { /** * - **/ + */ export const jsxAttribute = "JSX attribute"; } diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 1b32b3bbad71f..fe9a310ad4bf7 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -705,13 +705,13 @@ namespace ts { } /** - * The token on the left of the position is the token that strictly includes the position - * or sits to the left of the cursor if it is on a boundary. For example - * - * fo|o -> will return foo - * foo |bar -> will return foo - * - */ + * The token on the left of the position is the token that strictly includes the position + * or sits to the left of the cursor if it is on a boundary. For example + * + * fo|o -> will return foo + * foo |bar -> will return foo + * + */ export function findTokenOnLeftOfPosition(file: SourceFile, position: number): Node { // Ideally, getTokenAtPosition should return a token. However, it is currently // broken, so we do a check to make sure the result was indeed a token. @@ -1334,7 +1334,7 @@ namespace ts { name.charCodeAt(0) === name.charCodeAt(length - 1) && (name.charCodeAt(0) === CharacterCodes.doubleQuote || name.charCodeAt(0) === CharacterCodes.singleQuote)) { return name.substring(1, length - 1); - }; + } return name; } @@ -1380,8 +1380,19 @@ namespace ts { }; } + export function getFirstNonSpaceCharacterPosition(text: string, position: number) { + while (isWhiteSpace(text.charCodeAt(position))) { + position += 1; + } + return position; + } + export function getOpenBrace(constructor: ConstructorDeclaration, sourceFile: SourceFile) { // First token is the open curly, this is where we want to put the 'super' call. return constructor.body.getFirstToken(sourceFile); } + + export function getOpenBraceOfClassLike(declaration: ClassLikeDeclaration, sourceFile: SourceFile) { + return getTokenAtPosition(sourceFile, declaration.members.pos - 1); + } } diff --git a/tests/baselines/reference/APISample_compile.js b/tests/baselines/reference/APISample_compile.js index 0315fd516b5bd..c2617b2a6c6a3 100644 --- a/tests/baselines/reference/APISample_compile.js +++ b/tests/baselines/reference/APISample_compile.js @@ -1,5 +1,4 @@ //// [APISample_compile.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-minimal-compiler @@ -35,12 +34,12 @@ compile(process.argv.slice(2), { }); //// [APISample_compile.js] +"use strict"; /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-minimal-compiler * Please log a "breaking change" issue for any API breaking change affecting this issue */ -"use strict"; exports.__esModule = true; var ts = require("typescript"); function compile(fileNames, options) { diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js index 57ebd64c4e2bf..51b208c39c902 100644 --- a/tests/baselines/reference/APISample_linter.js +++ b/tests/baselines/reference/APISample_linter.js @@ -1,5 +1,4 @@ //// [APISample_linter.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter @@ -65,12 +64,12 @@ fileNames.forEach(fileName => { }); //// [APISample_linter.js] +"use strict"; /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter * Please log a "breaking change" issue for any API breaking change affecting this issue */ -"use strict"; exports.__esModule = true; var ts = require("typescript"); function delint(sourceFile) { diff --git a/tests/baselines/reference/APISample_parseConfig.js b/tests/baselines/reference/APISample_parseConfig.js index 77f0a07c1dff8..690efb359c641 100644 --- a/tests/baselines/reference/APISample_parseConfig.js +++ b/tests/baselines/reference/APISample_parseConfig.js @@ -1,5 +1,4 @@ //// [APISample_parseConfig.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-minimal-compiler @@ -37,12 +36,12 @@ export function createProgram(rootFiles: string[], compilerOptionsJson: string): } //// [APISample_parseConfig.js] +"use strict"; /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-minimal-compiler * Please log a "breaking change" issue for any API breaking change affecting this issue */ -"use strict"; exports.__esModule = true; var ts = require("typescript"); function printError(error) { diff --git a/tests/baselines/reference/APISample_transform.js b/tests/baselines/reference/APISample_transform.js index 0716e59edb774..47f63f56e704b 100644 --- a/tests/baselines/reference/APISample_transform.js +++ b/tests/baselines/reference/APISample_transform.js @@ -1,5 +1,4 @@ //// [APISample_transform.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-simple-transform-function @@ -17,12 +16,12 @@ let result = ts.transpile(source, { module: ts.ModuleKind.CommonJS }); console.log(JSON.stringify(result)); //// [APISample_transform.js] +"use strict"; /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-simple-transform-function * Please log a "breaking change" issue for any API breaking change affecting this issue */ -"use strict"; exports.__esModule = true; var ts = require("typescript"); var source = "let x: string = 'string'"; diff --git a/tests/baselines/reference/APISample_watcher.js b/tests/baselines/reference/APISample_watcher.js index f4400ccda4cc0..f06f9ced73fde 100644 --- a/tests/baselines/reference/APISample_watcher.js +++ b/tests/baselines/reference/APISample_watcher.js @@ -1,5 +1,4 @@ //// [APISample_watcher.ts] - /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#incremental-build-support-using-the-language-services @@ -110,12 +109,12 @@ const currentDirectoryFiles = fs.readdirSync(process.cwd()). watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS }); //// [APISample_watcher.js] +"use strict"; /* * Note: This test is a public API sample. The sample sources can be found at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#incremental-build-support-using-the-language-services * Please log a "breaking change" issue for any API breaking change affecting this issue */ -"use strict"; exports.__esModule = true; var ts = require("typescript"); function watch(rootFileNames, options) { diff --git a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.errors.txt b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.errors.txt index 1f442e98d12ea..0a8f03a504a52 100644 --- a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.errors.txt +++ b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts(4,8): error TS4033: Property 'f' of exported interface has or is using private name 'T'. +tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts(3,8): error TS4033: Property 'f' of exported interface has or is using private name 'T'. ==== tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts (1 errors) ==== - type T = { x : number } export interface I { f: T; diff --git a/tests/baselines/reference/ES5For-ofTypeCheck10.errors.txt b/tests/baselines/reference/ES5For-ofTypeCheck10.errors.txt index 7839958ba54ce..e608378d7f1e3 100644 --- a/tests/baselines/reference/ES5For-ofTypeCheck10.errors.txt +++ b/tests/baselines/reference/ES5For-ofTypeCheck10.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts(10,6): error TS2304: Cannot find name 'Symbol'. -tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts(15,15): error TS2495: Type 'StringIterator' is not an array type or a string type. +tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts(9,6): error TS2304: Cannot find name 'Symbol'. +tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts(14,15): error TS2495: Type 'StringIterator' is not an array type or a string type. ==== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts (2 errors) ==== - // In ES3/5, you cannot for...of over an arbitrary iterable. class StringIterator { next() { diff --git a/tests/baselines/reference/ES5For-ofTypeCheck10.js b/tests/baselines/reference/ES5For-ofTypeCheck10.js index 9b197c2d206d1..c4cfafe51990c 100644 --- a/tests/baselines/reference/ES5For-ofTypeCheck10.js +++ b/tests/baselines/reference/ES5For-ofTypeCheck10.js @@ -1,5 +1,4 @@ //// [ES5For-ofTypeCheck10.ts] - // In ES3/5, you cannot for...of over an arbitrary iterable. class StringIterator { next() { diff --git a/tests/baselines/reference/ES5for-of32.js b/tests/baselines/reference/ES5for-of32.js index 7af7cc3874a3a..747f9524062f6 100644 --- a/tests/baselines/reference/ES5for-of32.js +++ b/tests/baselines/reference/ES5for-of32.js @@ -1,5 +1,4 @@ //// [ES5for-of32.ts] - var array = [1,2,3]; var sum = 0; diff --git a/tests/baselines/reference/ES5for-of32.symbols b/tests/baselines/reference/ES5for-of32.symbols index 5672ad0110965..b6fa8810382d6 100644 --- a/tests/baselines/reference/ES5for-of32.symbols +++ b/tests/baselines/reference/ES5for-of32.symbols @@ -1,23 +1,22 @@ === tests/cases/conformance/statements/for-ofStatements/ES5for-of32.ts === - var array = [1,2,3]; ->array : Symbol(array, Decl(ES5for-of32.ts, 1, 3)) +>array : Symbol(array, Decl(ES5for-of32.ts, 0, 3)) var sum = 0; ->sum : Symbol(sum, Decl(ES5for-of32.ts, 2, 3)) +>sum : Symbol(sum, Decl(ES5for-of32.ts, 1, 3)) for (let num of array) { ->num : Symbol(num, Decl(ES5for-of32.ts, 4, 8)) ->array : Symbol(array, Decl(ES5for-of32.ts, 1, 3)) +>num : Symbol(num, Decl(ES5for-of32.ts, 3, 8)) +>array : Symbol(array, Decl(ES5for-of32.ts, 0, 3)) if (sum === 0) { ->sum : Symbol(sum, Decl(ES5for-of32.ts, 2, 3)) +>sum : Symbol(sum, Decl(ES5for-of32.ts, 1, 3)) array = [4,5,6] ->array : Symbol(array, Decl(ES5for-of32.ts, 1, 3)) +>array : Symbol(array, Decl(ES5for-of32.ts, 0, 3)) } sum += num; ->sum : Symbol(sum, Decl(ES5for-of32.ts, 2, 3)) ->num : Symbol(num, Decl(ES5for-of32.ts, 4, 8)) +>sum : Symbol(sum, Decl(ES5for-of32.ts, 1, 3)) +>num : Symbol(num, Decl(ES5for-of32.ts, 3, 8)) } diff --git a/tests/baselines/reference/ES5for-of32.types b/tests/baselines/reference/ES5for-of32.types index 188500c4859f3..22e387d8484e4 100644 --- a/tests/baselines/reference/ES5for-of32.types +++ b/tests/baselines/reference/ES5for-of32.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/for-ofStatements/ES5for-of32.ts === - var array = [1,2,3]; >array : number[] >[1,2,3] : number[] diff --git a/tests/baselines/reference/NonInitializedExportInInternalModule.errors.txt b/tests/baselines/reference/NonInitializedExportInInternalModule.errors.txt index a7b6b5de43d21..b6d4c4c69902f 100644 --- a/tests/baselines/reference/NonInitializedExportInInternalModule.errors.txt +++ b/tests/baselines/reference/NonInitializedExportInInternalModule.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(3,8): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(4,5): error TS2304: Cannot find name 'let'. -tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(5,10): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(2,8): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(3,5): error TS2304: Cannot find name 'let'. +tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts(4,10): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts (3 errors) ==== - module Inner { var; diff --git a/tests/baselines/reference/NonInitializedExportInInternalModule.js b/tests/baselines/reference/NonInitializedExportInInternalModule.js index aa1c84664ad07..129dd104282f6 100644 --- a/tests/baselines/reference/NonInitializedExportInInternalModule.js +++ b/tests/baselines/reference/NonInitializedExportInInternalModule.js @@ -1,5 +1,4 @@ //// [NonInitializedExportInInternalModule.ts] - module Inner { var; let; diff --git a/tests/baselines/reference/SystemModuleForStatementNoInitializer.js b/tests/baselines/reference/SystemModuleForStatementNoInitializer.js new file mode 100644 index 0000000000000..2ab13a47c8929 --- /dev/null +++ b/tests/baselines/reference/SystemModuleForStatementNoInitializer.js @@ -0,0 +1,41 @@ +//// [SystemModuleForStatementNoInitializer.ts] +export { }; + +let i = 0; +let limit = 10; + +for (; i < limit; ++i) { + break; +} + +for (; ; ++i) { + break; +} + +for (; ;) { + break; +} + + +//// [SystemModuleForStatementNoInitializer.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var __moduleName = context_1 && context_1.id; + var i, limit; + return { + setters: [], + execute: function () { + i = 0; + limit = 10; + for (; i < limit; ++i) { + break; + } + for (;; ++i) { + break; + } + for (;;) { + break; + } + } + }; +}); diff --git a/tests/baselines/reference/SystemModuleForStatementNoInitializer.symbols b/tests/baselines/reference/SystemModuleForStatementNoInitializer.symbols new file mode 100644 index 0000000000000..33144e07cf039 --- /dev/null +++ b/tests/baselines/reference/SystemModuleForStatementNoInitializer.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/SystemModuleForStatementNoInitializer.ts === +export { }; + +let i = 0; +>i : Symbol(i, Decl(SystemModuleForStatementNoInitializer.ts, 2, 3)) + +let limit = 10; +>limit : Symbol(limit, Decl(SystemModuleForStatementNoInitializer.ts, 3, 3)) + +for (; i < limit; ++i) { +>i : Symbol(i, Decl(SystemModuleForStatementNoInitializer.ts, 2, 3)) +>limit : Symbol(limit, Decl(SystemModuleForStatementNoInitializer.ts, 3, 3)) +>i : Symbol(i, Decl(SystemModuleForStatementNoInitializer.ts, 2, 3)) + + break; +} + +for (; ; ++i) { +>i : Symbol(i, Decl(SystemModuleForStatementNoInitializer.ts, 2, 3)) + + break; +} + +for (; ;) { + break; +} + diff --git a/tests/baselines/reference/SystemModuleForStatementNoInitializer.types b/tests/baselines/reference/SystemModuleForStatementNoInitializer.types new file mode 100644 index 0000000000000..7e876056c5a7a --- /dev/null +++ b/tests/baselines/reference/SystemModuleForStatementNoInitializer.types @@ -0,0 +1,32 @@ +=== tests/cases/compiler/SystemModuleForStatementNoInitializer.ts === +export { }; + +let i = 0; +>i : number +>0 : 0 + +let limit = 10; +>limit : number +>10 : 10 + +for (; i < limit; ++i) { +>i < limit : boolean +>i : number +>limit : number +>++i : number +>i : number + + break; +} + +for (; ; ++i) { +>++i : number +>i : number + + break; +} + +for (; ;) { + break; +} + diff --git a/tests/baselines/reference/VariableDeclaration12_es6.js b/tests/baselines/reference/VariableDeclaration12_es6.js index 1e7d6d4b3636a..da0748d2191a1 100644 --- a/tests/baselines/reference/VariableDeclaration12_es6.js +++ b/tests/baselines/reference/VariableDeclaration12_es6.js @@ -1,5 +1,4 @@ //// [VariableDeclaration12_es6.ts] - let x diff --git a/tests/baselines/reference/VariableDeclaration12_es6.symbols b/tests/baselines/reference/VariableDeclaration12_es6.symbols index a2f324502dd3c..5c4f583fbb25f 100644 --- a/tests/baselines/reference/VariableDeclaration12_es6.symbols +++ b/tests/baselines/reference/VariableDeclaration12_es6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/variableDeclarations/VariableDeclaration12_es6.ts === - let x ->x : Symbol(x, Decl(VariableDeclaration12_es6.ts, 1, 3)) +>x : Symbol(x, Decl(VariableDeclaration12_es6.ts, 0, 3)) diff --git a/tests/baselines/reference/VariableDeclaration12_es6.types b/tests/baselines/reference/VariableDeclaration12_es6.types index 14f23f88a7aa9..db8acdffd7926 100644 --- a/tests/baselines/reference/VariableDeclaration12_es6.types +++ b/tests/baselines/reference/VariableDeclaration12_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/variableDeclarations/VariableDeclaration12_es6.ts === - let x >x : any diff --git a/tests/baselines/reference/VariableDeclaration13_es6.errors.txt b/tests/baselines/reference/VariableDeclaration13_es6.errors.txt index a022a4ad52b43..1780e06e2af62 100644 --- a/tests/baselines/reference/VariableDeclaration13_es6.errors.txt +++ b/tests/baselines/reference/VariableDeclaration13_es6.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(5,5): error TS1181: Array element destructuring pattern expected. -tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(5,6): error TS1005: ',' expected. -tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(5,8): error TS1134: Variable declaration expected. -tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(5,10): error TS1134: Variable declaration expected. +tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(4,5): error TS1181: Array element destructuring pattern expected. +tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(4,6): error TS1005: ',' expected. +tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(4,8): error TS1134: Variable declaration expected. +tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts(4,10): error TS1134: Variable declaration expected. ==== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts (4 errors) ==== - // An ExpressionStatement cannot start with the two token sequence `let [` because // that would make it ambiguous with a `let` LexicalDeclaration whose first LexicalBinding was an ArrayBindingPattern. var let: any; diff --git a/tests/baselines/reference/VariableDeclaration13_es6.js b/tests/baselines/reference/VariableDeclaration13_es6.js index 4ec04b18c3a5e..1acd0fdbe0251 100644 --- a/tests/baselines/reference/VariableDeclaration13_es6.js +++ b/tests/baselines/reference/VariableDeclaration13_es6.js @@ -1,5 +1,4 @@ //// [VariableDeclaration13_es6.ts] - // An ExpressionStatement cannot start with the two token sequence `let [` because // that would make it ambiguous with a `let` LexicalDeclaration whose first LexicalBinding was an ArrayBindingPattern. var let: any; diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.js b/tests/baselines/reference/abstractInterfaceIdentifierName.js index 67058bfc6194a..1e60d065dbc8f 100644 --- a/tests/baselines/reference/abstractInterfaceIdentifierName.js +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.js @@ -1,5 +1,4 @@ //// [abstractInterfaceIdentifierName.ts] - interface abstract { abstract(): void; } diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.symbols b/tests/baselines/reference/abstractInterfaceIdentifierName.symbols index 29a1a361894af..9b8192db1d324 100644 --- a/tests/baselines/reference/abstractInterfaceIdentifierName.symbols +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/abstractInterfaceIdentifierName.ts === - interface abstract { >abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 0, 0)) abstract(): void; ->abstract : Symbol(abstract.abstract, Decl(abstractInterfaceIdentifierName.ts, 1, 20)) +>abstract : Symbol(abstract.abstract, Decl(abstractInterfaceIdentifierName.ts, 0, 20)) } diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.types b/tests/baselines/reference/abstractInterfaceIdentifierName.types index c6d30ca38a0c3..2aba754cfa094 100644 --- a/tests/baselines/reference/abstractInterfaceIdentifierName.types +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.types @@ -1,5 +1,4 @@ === tests/cases/compiler/abstractInterfaceIdentifierName.ts === - interface abstract { >abstract : abstract diff --git a/tests/baselines/reference/accessibilityModifiers.errors.txt b/tests/baselines/reference/accessibilityModifiers.errors.txt index 1bf92139761de..7d4351bd7b6b4 100644 --- a/tests/baselines/reference/accessibilityModifiers.errors.txt +++ b/tests/baselines/reference/accessibilityModifiers.errors.txt @@ -1,23 +1,22 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(21,12): error TS1029: 'private' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(22,12): error TS1029: 'private' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(23,12): error TS1029: 'private' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(24,12): error TS1029: 'private' modifier must precede 'static' modifier. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(25,12): error TS1029: 'private' modifier must precede 'static' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(26,12): error TS1029: 'protected' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(27,12): error TS1029: 'protected' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(28,12): error TS1029: 'protected' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(29,12): error TS1029: 'protected' modifier must precede 'static' modifier. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(30,12): error TS1029: 'protected' modifier must precede 'static' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(31,12): error TS1029: 'public' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(32,12): error TS1029: 'public' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(33,12): error TS1029: 'public' modifier must precede 'static' modifier. tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(34,12): error TS1029: 'public' modifier must precede 'static' modifier. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(35,12): error TS1029: 'public' modifier must precede 'static' modifier. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(40,13): error TS1028: Accessibility modifier already seen. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(41,12): error TS1028: Accessibility modifier already seen. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(42,13): error TS1028: Accessibility modifier already seen. -tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(43,12): error TS1028: Accessibility modifier already seen. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(39,13): error TS1028: Accessibility modifier already seen. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(40,12): error TS1028: Accessibility modifier already seen. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(41,13): error TS1028: Accessibility modifier already seen. +tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts(42,12): error TS1028: Accessibility modifier already seen. ==== tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts (16 errors) ==== - // No errors class C { private static privateProperty; diff --git a/tests/baselines/reference/accessibilityModifiers.js b/tests/baselines/reference/accessibilityModifiers.js index c50092d1459b5..ef092976ba8a0 100644 --- a/tests/baselines/reference/accessibilityModifiers.js +++ b/tests/baselines/reference/accessibilityModifiers.js @@ -1,5 +1,4 @@ //// [accessibilityModifiers.ts] - // No errors class C { private static privateProperty; diff --git a/tests/baselines/reference/accessorParameterAccessibilityModifier.errors.txt b/tests/baselines/reference/accessorParameterAccessibilityModifier.errors.txt index 3036e734105a7..17216739372f9 100644 --- a/tests/baselines/reference/accessorParameterAccessibilityModifier.errors.txt +++ b/tests/baselines/reference/accessorParameterAccessibilityModifier.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/accessorParameterAccessibilityModifier.ts(3,11): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/accessorParameterAccessibilityModifier.ts(4,18): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/accessorParameterAccessibilityModifier.ts(2,11): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/accessorParameterAccessibilityModifier.ts(3,18): error TS2369: A parameter property is only allowed in a constructor implementation. ==== tests/cases/compiler/accessorParameterAccessibilityModifier.ts (2 errors) ==== - class C { set X(public v) { } ~~~~~~~~ diff --git a/tests/baselines/reference/accessorParameterAccessibilityModifier.js b/tests/baselines/reference/accessorParameterAccessibilityModifier.js index 4aa8451feedfa..b0667ddc7266e 100644 --- a/tests/baselines/reference/accessorParameterAccessibilityModifier.js +++ b/tests/baselines/reference/accessorParameterAccessibilityModifier.js @@ -1,5 +1,4 @@ //// [accessorParameterAccessibilityModifier.ts] - class C { set X(public v) { } static set X(public v2) { } diff --git a/tests/baselines/reference/accessorWithES3.errors.txt b/tests/baselines/reference/accessorWithES3.errors.txt index 0b4510a12ca29..0a2219d85a463 100644 --- a/tests/baselines/reference/accessorWithES3.errors.txt +++ b/tests/baselines/reference/accessorWithES3.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(5,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(11,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(16,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(20,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(4,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(10,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(15,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts(19,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ==== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts (4 errors) ==== - // error to use accessors in ES3 mode class C { diff --git a/tests/baselines/reference/accessorWithES3.js b/tests/baselines/reference/accessorWithES3.js index 6384712fc9d85..84ea219547891 100644 --- a/tests/baselines/reference/accessorWithES3.js +++ b/tests/baselines/reference/accessorWithES3.js @@ -1,5 +1,4 @@ //// [accessorWithES3.ts] - // error to use accessors in ES3 mode class C { diff --git a/tests/baselines/reference/accessorWithES5.js b/tests/baselines/reference/accessorWithES5.js index 3a94de769882b..549ecd25e6513 100644 --- a/tests/baselines/reference/accessorWithES5.js +++ b/tests/baselines/reference/accessorWithES5.js @@ -1,5 +1,4 @@ //// [accessorWithES5.ts] - class C { get x() { return 1; diff --git a/tests/baselines/reference/accessorWithES5.symbols b/tests/baselines/reference/accessorWithES5.symbols index 46e8d6f91daea..1a0d8ee70eac6 100644 --- a/tests/baselines/reference/accessorWithES5.symbols +++ b/tests/baselines/reference/accessorWithES5.symbols @@ -1,35 +1,34 @@ === tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES5.ts === - class C { >C : Symbol(C, Decl(accessorWithES5.ts, 0, 0)) get x() { ->x : Symbol(C.x, Decl(accessorWithES5.ts, 1, 9)) +>x : Symbol(C.x, Decl(accessorWithES5.ts, 0, 9)) return 1; } } class D { ->D : Symbol(D, Decl(accessorWithES5.ts, 5, 1)) +>D : Symbol(D, Decl(accessorWithES5.ts, 4, 1)) set x(v) { ->x : Symbol(D.x, Decl(accessorWithES5.ts, 7, 9)) ->v : Symbol(v, Decl(accessorWithES5.ts, 8, 10)) +>x : Symbol(D.x, Decl(accessorWithES5.ts, 6, 9)) +>v : Symbol(v, Decl(accessorWithES5.ts, 7, 10)) } } var x = { ->x : Symbol(x, Decl(accessorWithES5.ts, 12, 3)) +>x : Symbol(x, Decl(accessorWithES5.ts, 11, 3)) get a() { return 1 } ->a : Symbol(a, Decl(accessorWithES5.ts, 12, 9)) +>a : Symbol(a, Decl(accessorWithES5.ts, 11, 9)) } var y = { ->y : Symbol(y, Decl(accessorWithES5.ts, 16, 3)) +>y : Symbol(y, Decl(accessorWithES5.ts, 15, 3)) set b(v) { } ->b : Symbol(b, Decl(accessorWithES5.ts, 16, 9)) ->v : Symbol(v, Decl(accessorWithES5.ts, 17, 10)) +>b : Symbol(b, Decl(accessorWithES5.ts, 15, 9)) +>v : Symbol(v, Decl(accessorWithES5.ts, 16, 10)) } diff --git a/tests/baselines/reference/accessorWithES5.types b/tests/baselines/reference/accessorWithES5.types index 4d23f61c0eb68..604f7c4301b30 100644 --- a/tests/baselines/reference/accessorWithES5.types +++ b/tests/baselines/reference/accessorWithES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES5.ts === - class C { >C : C diff --git a/tests/baselines/reference/accessorWithInitializer.errors.txt b/tests/baselines/reference/accessorWithInitializer.errors.txt index 338d9559e4cb4..1e64be49a1e66 100644 --- a/tests/baselines/reference/accessorWithInitializer.errors.txt +++ b/tests/baselines/reference/accessorWithInitializer.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/accessorWithInitializer.ts(3,9): error TS1052: A 'set' accessor parameter cannot have an initializer. -tests/cases/compiler/accessorWithInitializer.ts(4,16): error TS1052: A 'set' accessor parameter cannot have an initializer. +tests/cases/compiler/accessorWithInitializer.ts(2,9): error TS1052: A 'set' accessor parameter cannot have an initializer. +tests/cases/compiler/accessorWithInitializer.ts(3,16): error TS1052: A 'set' accessor parameter cannot have an initializer. ==== tests/cases/compiler/accessorWithInitializer.ts (2 errors) ==== - class C { set X(v = 0) { } ~ diff --git a/tests/baselines/reference/accessorWithInitializer.js b/tests/baselines/reference/accessorWithInitializer.js index d4562e635dce5..2d2e03a05da57 100644 --- a/tests/baselines/reference/accessorWithInitializer.js +++ b/tests/baselines/reference/accessorWithInitializer.js @@ -1,5 +1,4 @@ //// [accessorWithInitializer.ts] - class C { set X(v = 0) { } static set X(v2 = 0) { } diff --git a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.errors.txt b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.errors.txt index 6c12df93dd166..9d1b7ca9a30b5 100644 --- a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.errors.txt +++ b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(3,9): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(6,17): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(11,19): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(14,17): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(19,19): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(21,9): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(27,26): error TS2379: Getter and setter accessors do not agree in visibility. -tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(29,16): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(2,9): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(5,17): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(10,19): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(13,17): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(18,19): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(20,9): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(26,26): error TS2379: Getter and setter accessors do not agree in visibility. +tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts(28,16): error TS2379: Getter and setter accessors do not agree in visibility. ==== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts (8 errors) ==== - class C { get x() { ~ diff --git a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.js b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.js index 9dc206971a121..c33259a82b611 100644 --- a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.js +++ b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.js @@ -1,5 +1,4 @@ //// [accessorWithMismatchedAccessibilityModifiers.ts] - class C { get x() { return 1; diff --git a/tests/baselines/reference/accessorWithRestParam.errors.txt b/tests/baselines/reference/accessorWithRestParam.errors.txt index c6f3ef70563c3..ae06df99c95ed 100644 --- a/tests/baselines/reference/accessorWithRestParam.errors.txt +++ b/tests/baselines/reference/accessorWithRestParam.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/accessorWithRestParam.ts(3,11): error TS1053: A 'set' accessor cannot have rest parameter. -tests/cases/compiler/accessorWithRestParam.ts(4,18): error TS1053: A 'set' accessor cannot have rest parameter. +tests/cases/compiler/accessorWithRestParam.ts(2,11): error TS1053: A 'set' accessor cannot have rest parameter. +tests/cases/compiler/accessorWithRestParam.ts(3,18): error TS1053: A 'set' accessor cannot have rest parameter. ==== tests/cases/compiler/accessorWithRestParam.ts (2 errors) ==== - class C { set X(...v) { } ~~~ diff --git a/tests/baselines/reference/accessorWithRestParam.js b/tests/baselines/reference/accessorWithRestParam.js index 871f3ed00efa0..63169b3cacb2b 100644 --- a/tests/baselines/reference/accessorWithRestParam.js +++ b/tests/baselines/reference/accessorWithRestParam.js @@ -1,5 +1,4 @@ //// [accessorWithRestParam.ts] - class C { set X(...v) { } static set X(...v2) { } diff --git a/tests/baselines/reference/accessorsInAmbientContext.errors.txt b/tests/baselines/reference/accessorsInAmbientContext.errors.txt index ada59f21f652b..44b100bd58ddb 100644 --- a/tests/baselines/reference/accessorsInAmbientContext.errors.txt +++ b/tests/baselines/reference/accessorsInAmbientContext.errors.txt @@ -1,15 +1,14 @@ +tests/cases/compiler/accessorsInAmbientContext.ts(3,13): error TS1086: An accessor cannot be declared in an ambient context. tests/cases/compiler/accessorsInAmbientContext.ts(4,13): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/accessorsInAmbientContext.ts(5,13): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/accessorsInAmbientContext.ts(6,20): error TS1086: An accessor cannot be declared in an ambient context. tests/cases/compiler/accessorsInAmbientContext.ts(7,20): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/accessorsInAmbientContext.ts(8,20): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/accessorsInAmbientContext.ts(12,9): error TS1086: An accessor cannot be declared in an ambient context. tests/cases/compiler/accessorsInAmbientContext.ts(13,9): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/accessorsInAmbientContext.ts(14,9): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/accessorsInAmbientContext.ts(15,16): error TS1086: An accessor cannot be declared in an ambient context. tests/cases/compiler/accessorsInAmbientContext.ts(16,16): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/accessorsInAmbientContext.ts(17,16): error TS1086: An accessor cannot be declared in an ambient context. ==== tests/cases/compiler/accessorsInAmbientContext.ts (8 errors) ==== - declare module M { class C { get X() { return 1; } diff --git a/tests/baselines/reference/accessorsInAmbientContext.js b/tests/baselines/reference/accessorsInAmbientContext.js index e60831ede5b39..8e608edae1a50 100644 --- a/tests/baselines/reference/accessorsInAmbientContext.js +++ b/tests/baselines/reference/accessorsInAmbientContext.js @@ -1,5 +1,4 @@ //// [accessorsInAmbientContext.ts] - declare module M { class C { get X() { return 1; } diff --git a/tests/baselines/reference/accessorsNotAllowedInES3.errors.txt b/tests/baselines/reference/accessorsNotAllowedInES3.errors.txt index f7d7b146ee3de..cee1c8fd537ee 100644 --- a/tests/baselines/reference/accessorsNotAllowedInES3.errors.txt +++ b/tests/baselines/reference/accessorsNotAllowedInES3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/accessorsNotAllowedInES3.ts(3,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/accessorsNotAllowedInES3.ts(5,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/accessorsNotAllowedInES3.ts(2,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/accessorsNotAllowedInES3.ts(4,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ==== tests/cases/compiler/accessorsNotAllowedInES3.ts (2 errors) ==== - class C { get x(): number { return 1; } ~ diff --git a/tests/baselines/reference/accessorsNotAllowedInES3.js b/tests/baselines/reference/accessorsNotAllowedInES3.js index e348771b8f6aa..2d26c0643f9d5 100644 --- a/tests/baselines/reference/accessorsNotAllowedInES3.js +++ b/tests/baselines/reference/accessorsNotAllowedInES3.js @@ -1,5 +1,4 @@ //// [accessorsNotAllowedInES3.ts] - class C { get x(): number { return 1; } } diff --git a/tests/baselines/reference/aliasBug.errors.txt b/tests/baselines/reference/aliasBug.errors.txt index 0c8dd7d034f47..70f6409ef21f4 100644 --- a/tests/baselines/reference/aliasBug.errors.txt +++ b/tests/baselines/reference/aliasBug.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/aliasBug.ts(17,15): error TS2694: Namespace 'foo.bar.baz' has no exported member 'bar'. +tests/cases/compiler/aliasBug.ts(16,15): error TS2694: Namespace 'foo.bar.baz' has no exported member 'bar'. ==== tests/cases/compiler/aliasBug.ts (1 errors) ==== - module foo { export class Provide { } diff --git a/tests/baselines/reference/aliasBug.js b/tests/baselines/reference/aliasBug.js index be7201a8ea78a..99d45bf1ae067 100644 --- a/tests/baselines/reference/aliasBug.js +++ b/tests/baselines/reference/aliasBug.js @@ -1,5 +1,4 @@ //// [aliasBug.ts] - module foo { export class Provide { } diff --git a/tests/baselines/reference/aliasesInSystemModule1.errors.txt b/tests/baselines/reference/aliasesInSystemModule1.errors.txt index 9b89332e458fa..d84223cc8a3ee 100644 --- a/tests/baselines/reference/aliasesInSystemModule1.errors.txt +++ b/tests/baselines/reference/aliasesInSystemModule1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/aliasesInSystemModule1.ts(2,24): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/aliasesInSystemModule1.ts(1,24): error TS2307: Cannot find module 'foo'. ==== tests/cases/compiler/aliasesInSystemModule1.ts (1 errors) ==== - import alias = require('foo'); ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/aliasesInSystemModule1.js b/tests/baselines/reference/aliasesInSystemModule1.js index 24d7a5d1b0b70..f940dd04597ab 100644 --- a/tests/baselines/reference/aliasesInSystemModule1.js +++ b/tests/baselines/reference/aliasesInSystemModule1.js @@ -1,5 +1,4 @@ //// [aliasesInSystemModule1.ts] - import alias = require('foo'); import cls = alias.Class; export import cls2 = alias.Class; diff --git a/tests/baselines/reference/aliasesInSystemModule2.errors.txt b/tests/baselines/reference/aliasesInSystemModule2.errors.txt index 618e61c7f3cd5..a1456b04cd824 100644 --- a/tests/baselines/reference/aliasesInSystemModule2.errors.txt +++ b/tests/baselines/reference/aliasesInSystemModule2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/aliasesInSystemModule2.ts(2,21): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/aliasesInSystemModule2.ts(1,21): error TS2307: Cannot find module 'foo'. ==== tests/cases/compiler/aliasesInSystemModule2.ts (1 errors) ==== - import {alias} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/aliasesInSystemModule2.js b/tests/baselines/reference/aliasesInSystemModule2.js index 71fe558d43a1b..5ef48a52cde10 100644 --- a/tests/baselines/reference/aliasesInSystemModule2.js +++ b/tests/baselines/reference/aliasesInSystemModule2.js @@ -1,5 +1,4 @@ //// [aliasesInSystemModule2.ts] - import {alias} from "foo"; import cls = alias.Class; export import cls2 = alias.Class; diff --git a/tests/baselines/reference/alwaysStrict.errors.txt b/tests/baselines/reference/alwaysStrict.errors.txt index d7fcfb45801c7..55ec2eb5880e4 100644 --- a/tests/baselines/reference/alwaysStrict.errors.txt +++ b/tests/baselines/reference/alwaysStrict.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/alwaysStrict.ts(3,9): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/alwaysStrict.ts(2,9): error TS1100: Invalid use of 'arguments' in strict mode. ==== tests/cases/compiler/alwaysStrict.ts (1 errors) ==== - function f() { var arguments = []; ~~~~~~~~~ diff --git a/tests/baselines/reference/alwaysStrict.js b/tests/baselines/reference/alwaysStrict.js index bc5f9a2991205..c3580ec2c1cd7 100644 --- a/tests/baselines/reference/alwaysStrict.js +++ b/tests/baselines/reference/alwaysStrict.js @@ -1,5 +1,4 @@ //// [alwaysStrict.ts] - function f() { var arguments = []; } diff --git a/tests/baselines/reference/alwaysStrictES6.errors.txt b/tests/baselines/reference/alwaysStrictES6.errors.txt index b775a6e475513..f59c9a3c0408f 100644 --- a/tests/baselines/reference/alwaysStrictES6.errors.txt +++ b/tests/baselines/reference/alwaysStrictES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/alwaysStrictES6.ts(3,9): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/alwaysStrictES6.ts(2,9): error TS1100: Invalid use of 'arguments' in strict mode. ==== tests/cases/compiler/alwaysStrictES6.ts (1 errors) ==== - function f() { var arguments = []; ~~~~~~~~~ diff --git a/tests/baselines/reference/alwaysStrictES6.js b/tests/baselines/reference/alwaysStrictES6.js index 2c7ad36bce2a5..7b2e0e28e9ec3 100644 --- a/tests/baselines/reference/alwaysStrictES6.js +++ b/tests/baselines/reference/alwaysStrictES6.js @@ -1,5 +1,4 @@ //// [alwaysStrictES6.ts] - function f() { var arguments = []; } diff --git a/tests/baselines/reference/alwaysStrictModule.errors.txt b/tests/baselines/reference/alwaysStrictModule.errors.txt index 90c1a0b930acb..61e3db4a4825d 100644 --- a/tests/baselines/reference/alwaysStrictModule.errors.txt +++ b/tests/baselines/reference/alwaysStrictModule.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/alwaysStrictModule.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/alwaysStrictModule.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode. ==== tests/cases/compiler/alwaysStrictModule.ts (1 errors) ==== - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/alwaysStrictModule.js b/tests/baselines/reference/alwaysStrictModule.js index f39c87ed96c75..f5c5835df5f1e 100644 --- a/tests/baselines/reference/alwaysStrictModule.js +++ b/tests/baselines/reference/alwaysStrictModule.js @@ -1,5 +1,4 @@ //// [alwaysStrictModule.ts] - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/alwaysStrictModule2.errors.txt b/tests/baselines/reference/alwaysStrictModule2.errors.txt index 3980d24abfc03..ef43d82f33d48 100644 --- a/tests/baselines/reference/alwaysStrictModule2.errors.txt +++ b/tests/baselines/reference/alwaysStrictModule2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/a.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/a.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode. tests/cases/compiler/b.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode. ==== tests/cases/compiler/a.ts (1 errors) ==== - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/alwaysStrictModule2.js b/tests/baselines/reference/alwaysStrictModule2.js index 54f179ff10b2d..157e11e760ad2 100644 --- a/tests/baselines/reference/alwaysStrictModule2.js +++ b/tests/baselines/reference/alwaysStrictModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/alwaysStrictModule2.ts] //// //// [a.ts] - module M { export function f() { var arguments = []; @@ -24,7 +23,6 @@ var M; } M.f = f; })(M || (M = {})); -"use strict"; var M; (function (M) { function f2() { diff --git a/tests/baselines/reference/alwaysStrictModule3.js b/tests/baselines/reference/alwaysStrictModule3.js index 894bad25143d9..2eb8de840288e 100644 --- a/tests/baselines/reference/alwaysStrictModule3.js +++ b/tests/baselines/reference/alwaysStrictModule3.js @@ -1,8 +1,8 @@ //// [alwaysStrictModule3.ts] - // module ES2015 export const a = 1; //// [alwaysStrictModule3.js] // module ES2015 +// module ES2015 export var a = 1; diff --git a/tests/baselines/reference/alwaysStrictModule3.symbols b/tests/baselines/reference/alwaysStrictModule3.symbols index 6f053673f0e40..0e615b13b9d0f 100644 --- a/tests/baselines/reference/alwaysStrictModule3.symbols +++ b/tests/baselines/reference/alwaysStrictModule3.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/alwaysStrictModule3.ts === - // module ES2015 export const a = 1; ->a : Symbol(a, Decl(alwaysStrictModule3.ts, 2, 12)) +>a : Symbol(a, Decl(alwaysStrictModule3.ts, 1, 12)) diff --git a/tests/baselines/reference/alwaysStrictModule3.types b/tests/baselines/reference/alwaysStrictModule3.types index 75b11206a4f7a..2c972c392eade 100644 --- a/tests/baselines/reference/alwaysStrictModule3.types +++ b/tests/baselines/reference/alwaysStrictModule3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/alwaysStrictModule3.ts === - // module ES2015 export const a = 1; >a : 1 diff --git a/tests/baselines/reference/alwaysStrictModule4.js b/tests/baselines/reference/alwaysStrictModule4.js index dcaafdfeee6f6..026570293be82 100644 --- a/tests/baselines/reference/alwaysStrictModule4.js +++ b/tests/baselines/reference/alwaysStrictModule4.js @@ -1,5 +1,4 @@ //// [alwaysStrictModule4.ts] - // Module commonjs export const a = 1 diff --git a/tests/baselines/reference/alwaysStrictModule4.symbols b/tests/baselines/reference/alwaysStrictModule4.symbols index 4b8a968ae165d..aaaf3d5c11d98 100644 --- a/tests/baselines/reference/alwaysStrictModule4.symbols +++ b/tests/baselines/reference/alwaysStrictModule4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/alwaysStrictModule4.ts === - // Module commonjs export const a = 1 ->a : Symbol(a, Decl(alwaysStrictModule4.ts, 2, 12)) +>a : Symbol(a, Decl(alwaysStrictModule4.ts, 1, 12)) diff --git a/tests/baselines/reference/alwaysStrictModule4.types b/tests/baselines/reference/alwaysStrictModule4.types index fff87967605c9..134aebd585f9b 100644 --- a/tests/baselines/reference/alwaysStrictModule4.types +++ b/tests/baselines/reference/alwaysStrictModule4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/alwaysStrictModule4.ts === - // Module commonjs export const a = 1 >a : 1 diff --git a/tests/baselines/reference/alwaysStrictModule5.js b/tests/baselines/reference/alwaysStrictModule5.js index 74b9d72263c4c..2356df0e3933c 100644 --- a/tests/baselines/reference/alwaysStrictModule5.js +++ b/tests/baselines/reference/alwaysStrictModule5.js @@ -1,8 +1,8 @@ //// [alwaysStrictModule5.ts] - // Targeting ES6 export const a = 1; //// [alwaysStrictModule5.js] // Targeting ES6 +// Targeting ES6 export const a = 1; diff --git a/tests/baselines/reference/alwaysStrictModule5.symbols b/tests/baselines/reference/alwaysStrictModule5.symbols index 903bf3c5c9893..cab5143a74077 100644 --- a/tests/baselines/reference/alwaysStrictModule5.symbols +++ b/tests/baselines/reference/alwaysStrictModule5.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/alwaysStrictModule5.ts === - // Targeting ES6 export const a = 1; ->a : Symbol(a, Decl(alwaysStrictModule5.ts, 2, 12)) +>a : Symbol(a, Decl(alwaysStrictModule5.ts, 1, 12)) diff --git a/tests/baselines/reference/alwaysStrictModule5.types b/tests/baselines/reference/alwaysStrictModule5.types index 2bfa329ad7e8d..8193c57ee1249 100644 --- a/tests/baselines/reference/alwaysStrictModule5.types +++ b/tests/baselines/reference/alwaysStrictModule5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/alwaysStrictModule5.ts === - // Targeting ES6 export const a = 1; >a : 1 diff --git a/tests/baselines/reference/alwaysStrictModule6.js b/tests/baselines/reference/alwaysStrictModule6.js index cd97b55b67bac..2c64e06582e4f 100644 --- a/tests/baselines/reference/alwaysStrictModule6.js +++ b/tests/baselines/reference/alwaysStrictModule6.js @@ -1,5 +1,4 @@ //// [alwaysStrictModule6.ts] - // Targeting ES5 export const a = 1; diff --git a/tests/baselines/reference/alwaysStrictModule6.symbols b/tests/baselines/reference/alwaysStrictModule6.symbols index 59a70f3e5b5fe..33ed3c37cf418 100644 --- a/tests/baselines/reference/alwaysStrictModule6.symbols +++ b/tests/baselines/reference/alwaysStrictModule6.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/alwaysStrictModule6.ts === - // Targeting ES5 export const a = 1; ->a : Symbol(a, Decl(alwaysStrictModule6.ts, 2, 12)) +>a : Symbol(a, Decl(alwaysStrictModule6.ts, 1, 12)) diff --git a/tests/baselines/reference/alwaysStrictModule6.types b/tests/baselines/reference/alwaysStrictModule6.types index 0970380911eb3..dc6e6e347662c 100644 --- a/tests/baselines/reference/alwaysStrictModule6.types +++ b/tests/baselines/reference/alwaysStrictModule6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/alwaysStrictModule6.ts === - // Targeting ES5 export const a = 1; >a : 1 diff --git a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt index 8df1d76e546b8..1c228e9b31a74 100644 --- a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt +++ b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt @@ -1,10 +1,9 @@ error TS5053: Option 'noImplicitUseStrict' cannot be specified with option 'alwaysStrict'. -tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode. +tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode. !!! error TS5053: Option 'noImplicitUseStrict' cannot be specified with option 'alwaysStrict'. ==== tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts (1 errors) ==== - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js index cfa7f69629f74..ff5a1166a89f4 100644 --- a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js +++ b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js @@ -1,5 +1,4 @@ //// [alwaysStrictNoImplicitUseStrict.ts] - module M { export function f() { var arguments = []; diff --git a/tests/baselines/reference/ambientClassDeclarationWithExtends.js b/tests/baselines/reference/ambientClassDeclarationWithExtends.js index 940efb8899f86..1b7bcf88b2084 100644 --- a/tests/baselines/reference/ambientClassDeclarationWithExtends.js +++ b/tests/baselines/reference/ambientClassDeclarationWithExtends.js @@ -13,14 +13,12 @@ declare class D extends C { } var d: C = new D(); //// [ambientClassDeclarationExtends_file1.ts] - declare class E { public bar; } namespace F { var y; } //// [ambientClassDeclarationExtends_file2.ts] - declare class F extends E { } var f: E = new F(); diff --git a/tests/baselines/reference/ambientClassDeclarationWithExtends.symbols b/tests/baselines/reference/ambientClassDeclarationWithExtends.symbols index 125bd0d0e5f11..652b3eee3cbb1 100644 --- a/tests/baselines/reference/ambientClassDeclarationWithExtends.symbols +++ b/tests/baselines/reference/ambientClassDeclarationWithExtends.symbols @@ -26,25 +26,23 @@ var d: C = new D(); >D : Symbol(D, Decl(ambientClassDeclarationExtends_singleFile.ts, 5, 1), Decl(ambientClassDeclarationExtends_singleFile.ts, 6, 22)) === tests/cases/compiler/ambientClassDeclarationExtends_file1.ts === - declare class E { >E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0)) public bar; ->bar : Symbol(E.bar, Decl(ambientClassDeclarationExtends_file1.ts, 1, 17)) +>bar : Symbol(E.bar, Decl(ambientClassDeclarationExtends_file1.ts, 0, 17)) } namespace F { var y; } ->F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) ->y : Symbol(y, Decl(ambientClassDeclarationExtends_file1.ts, 4, 17)) +>F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 2, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) +>y : Symbol(y, Decl(ambientClassDeclarationExtends_file1.ts, 3, 17)) === tests/cases/compiler/ambientClassDeclarationExtends_file2.ts === - declare class F extends E { } ->F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) +>F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 2, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) >E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0)) var f: E = new F(); ->f : Symbol(f, Decl(ambientClassDeclarationExtends_file2.ts, 2, 3)) +>f : Symbol(f, Decl(ambientClassDeclarationExtends_file2.ts, 1, 3)) >E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0)) ->F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) +>F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 2, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0)) diff --git a/tests/baselines/reference/ambientClassDeclarationWithExtends.types b/tests/baselines/reference/ambientClassDeclarationWithExtends.types index c7f22eeb65fba..75040fb08d973 100644 --- a/tests/baselines/reference/ambientClassDeclarationWithExtends.types +++ b/tests/baselines/reference/ambientClassDeclarationWithExtends.types @@ -27,7 +27,6 @@ var d: C = new D(); >D : typeof D === tests/cases/compiler/ambientClassDeclarationExtends_file1.ts === - declare class E { >E : E @@ -39,7 +38,6 @@ namespace F { var y; } >y : any === tests/cases/compiler/ambientClassDeclarationExtends_file2.ts === - declare class F extends E { } >F : F >E : E diff --git a/tests/baselines/reference/ambientClassDeclaredBeforeBase.symbols b/tests/baselines/reference/ambientClassDeclaredBeforeBase.symbols index 0d9fed7724006..6ed3e374e5590 100644 --- a/tests/baselines/reference/ambientClassDeclaredBeforeBase.symbols +++ b/tests/baselines/reference/ambientClassDeclaredBeforeBase.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/a.d.ts === - declare namespace ns { >ns : Symbol(ns, Decl(a.d.ts, 0, 0)) class SecondNS extends FirstNS { } ->SecondNS : Symbol(SecondNS, Decl(a.d.ts, 1, 22)) ->FirstNS : Symbol(FirstNS, Decl(a.d.ts, 2, 36)) +>SecondNS : Symbol(SecondNS, Decl(a.d.ts, 0, 22)) +>FirstNS : Symbol(FirstNS, Decl(a.d.ts, 1, 36)) class FirstNS { } ->FirstNS : Symbol(FirstNS, Decl(a.d.ts, 2, 36)) +>FirstNS : Symbol(FirstNS, Decl(a.d.ts, 1, 36)) } diff --git a/tests/baselines/reference/ambientClassDeclaredBeforeBase.types b/tests/baselines/reference/ambientClassDeclaredBeforeBase.types index 554d3cfcce8e0..2e3e5b453e07b 100644 --- a/tests/baselines/reference/ambientClassDeclaredBeforeBase.types +++ b/tests/baselines/reference/ambientClassDeclaredBeforeBase.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.d.ts === - declare namespace ns { >ns : typeof ns diff --git a/tests/baselines/reference/ambientConstLiterals.js b/tests/baselines/reference/ambientConstLiterals.js index 4a590826b1d80..ca5a5d28699a1 100644 --- a/tests/baselines/reference/ambientConstLiterals.js +++ b/tests/baselines/reference/ambientConstLiterals.js @@ -1,5 +1,4 @@ //// [ambientConstLiterals.ts] - function f(x: T): T { return x; } diff --git a/tests/baselines/reference/ambientConstLiterals.symbols b/tests/baselines/reference/ambientConstLiterals.symbols index 67d168a07502f..3ab4309259a53 100644 --- a/tests/baselines/reference/ambientConstLiterals.symbols +++ b/tests/baselines/reference/ambientConstLiterals.symbols @@ -1,74 +1,73 @@ === tests/cases/compiler/ambientConstLiterals.ts === - function f(x: T): T { >f : Symbol(f, Decl(ambientConstLiterals.ts, 0, 0)) ->T : Symbol(T, Decl(ambientConstLiterals.ts, 1, 11)) ->x : Symbol(x, Decl(ambientConstLiterals.ts, 1, 14)) ->T : Symbol(T, Decl(ambientConstLiterals.ts, 1, 11)) ->T : Symbol(T, Decl(ambientConstLiterals.ts, 1, 11)) +>T : Symbol(T, Decl(ambientConstLiterals.ts, 0, 11)) +>x : Symbol(x, Decl(ambientConstLiterals.ts, 0, 14)) +>T : Symbol(T, Decl(ambientConstLiterals.ts, 0, 11)) +>T : Symbol(T, Decl(ambientConstLiterals.ts, 0, 11)) return x; ->x : Symbol(x, Decl(ambientConstLiterals.ts, 1, 14)) +>x : Symbol(x, Decl(ambientConstLiterals.ts, 0, 14)) } enum E { A, B, C } ->E : Symbol(E, Decl(ambientConstLiterals.ts, 3, 1)) ->A : Symbol(E.A, Decl(ambientConstLiterals.ts, 5, 8)) ->B : Symbol(E.B, Decl(ambientConstLiterals.ts, 5, 11)) ->C : Symbol(E.C, Decl(ambientConstLiterals.ts, 5, 14)) +>E : Symbol(E, Decl(ambientConstLiterals.ts, 2, 1)) +>A : Symbol(E.A, Decl(ambientConstLiterals.ts, 4, 8)) +>B : Symbol(E.B, Decl(ambientConstLiterals.ts, 4, 11)) +>C : Symbol(E.C, Decl(ambientConstLiterals.ts, 4, 14)) const c1 = "abc"; ->c1 : Symbol(c1, Decl(ambientConstLiterals.ts, 7, 5)) +>c1 : Symbol(c1, Decl(ambientConstLiterals.ts, 6, 5)) const c2 = 123; ->c2 : Symbol(c2, Decl(ambientConstLiterals.ts, 8, 5)) +>c2 : Symbol(c2, Decl(ambientConstLiterals.ts, 7, 5)) const c3 = c1; ->c3 : Symbol(c3, Decl(ambientConstLiterals.ts, 9, 5)) ->c1 : Symbol(c1, Decl(ambientConstLiterals.ts, 7, 5)) +>c3 : Symbol(c3, Decl(ambientConstLiterals.ts, 8, 5)) +>c1 : Symbol(c1, Decl(ambientConstLiterals.ts, 6, 5)) const c4 = c2; ->c4 : Symbol(c4, Decl(ambientConstLiterals.ts, 10, 5)) ->c2 : Symbol(c2, Decl(ambientConstLiterals.ts, 8, 5)) +>c4 : Symbol(c4, Decl(ambientConstLiterals.ts, 9, 5)) +>c2 : Symbol(c2, Decl(ambientConstLiterals.ts, 7, 5)) const c5 = f(123); ->c5 : Symbol(c5, Decl(ambientConstLiterals.ts, 11, 5)) +>c5 : Symbol(c5, Decl(ambientConstLiterals.ts, 10, 5)) >f : Symbol(f, Decl(ambientConstLiterals.ts, 0, 0)) const c6 = f(-123); ->c6 : Symbol(c6, Decl(ambientConstLiterals.ts, 12, 5)) +>c6 : Symbol(c6, Decl(ambientConstLiterals.ts, 11, 5)) >f : Symbol(f, Decl(ambientConstLiterals.ts, 0, 0)) const c7 = true; ->c7 : Symbol(c7, Decl(ambientConstLiterals.ts, 13, 5)) +>c7 : Symbol(c7, Decl(ambientConstLiterals.ts, 12, 5)) const c8 = E.A; ->c8 : Symbol(c8, Decl(ambientConstLiterals.ts, 14, 5)) ->E.A : Symbol(E.A, Decl(ambientConstLiterals.ts, 5, 8)) ->E : Symbol(E, Decl(ambientConstLiterals.ts, 3, 1)) ->A : Symbol(E.A, Decl(ambientConstLiterals.ts, 5, 8)) +>c8 : Symbol(c8, Decl(ambientConstLiterals.ts, 13, 5)) +>E.A : Symbol(E.A, Decl(ambientConstLiterals.ts, 4, 8)) +>E : Symbol(E, Decl(ambientConstLiterals.ts, 2, 1)) +>A : Symbol(E.A, Decl(ambientConstLiterals.ts, 4, 8)) const c9 = { x: "abc" }; ->c9 : Symbol(c9, Decl(ambientConstLiterals.ts, 15, 5)) ->x : Symbol(x, Decl(ambientConstLiterals.ts, 15, 12)) +>c9 : Symbol(c9, Decl(ambientConstLiterals.ts, 14, 5)) +>x : Symbol(x, Decl(ambientConstLiterals.ts, 14, 12)) const c10 = [123]; ->c10 : Symbol(c10, Decl(ambientConstLiterals.ts, 16, 5)) +>c10 : Symbol(c10, Decl(ambientConstLiterals.ts, 15, 5)) const c11 = "abc" + "def"; ->c11 : Symbol(c11, Decl(ambientConstLiterals.ts, 17, 5)) +>c11 : Symbol(c11, Decl(ambientConstLiterals.ts, 16, 5)) const c12 = 123 + 456; ->c12 : Symbol(c12, Decl(ambientConstLiterals.ts, 18, 5)) +>c12 : Symbol(c12, Decl(ambientConstLiterals.ts, 17, 5)) const c13 = Math.random() > 0.5 ? "abc" : "def"; ->c13 : Symbol(c13, Decl(ambientConstLiterals.ts, 19, 5)) +>c13 : Symbol(c13, Decl(ambientConstLiterals.ts, 18, 5)) >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) const c14 = Math.random() > 0.5 ? 123 : 456; ->c14 : Symbol(c14, Decl(ambientConstLiterals.ts, 20, 5)) +>c14 : Symbol(c14, Decl(ambientConstLiterals.ts, 19, 5)) >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/ambientConstLiterals.types b/tests/baselines/reference/ambientConstLiterals.types index 8b6fc98462881..6f8a477b94da1 100644 --- a/tests/baselines/reference/ambientConstLiterals.types +++ b/tests/baselines/reference/ambientConstLiterals.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ambientConstLiterals.ts === - function f(x: T): T { >f : (x: T) => T >T : T diff --git a/tests/baselines/reference/ambientDeclarationsExternal.js b/tests/baselines/reference/ambientDeclarationsExternal.js index dfff030b78f47..fb5315864678b 100644 --- a/tests/baselines/reference/ambientDeclarationsExternal.js +++ b/tests/baselines/reference/ambientDeclarationsExternal.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/ambient/ambientDeclarationsExternal.ts] //// //// [decls.ts] - // Ambient external module with export assignment declare module 'equ' { var x; diff --git a/tests/baselines/reference/ambientDeclarationsExternal.symbols b/tests/baselines/reference/ambientDeclarationsExternal.symbols index f160751a19bc6..57d3fdf914f3a 100644 --- a/tests/baselines/reference/ambientDeclarationsExternal.symbols +++ b/tests/baselines/reference/ambientDeclarationsExternal.symbols @@ -10,27 +10,26 @@ import imp3 = require('equ2'); var n = imp3.x; >n : Symbol(n, Decl(consumer.ts, 6, 3), Decl(consumer.ts, 7, 3)) ->imp3.x : Symbol(imp3.x, Decl(decls.ts, 8, 7)) +>imp3.x : Symbol(imp3.x, Decl(decls.ts, 7, 7)) >imp3 : Symbol(imp3, Decl(consumer.ts, 1, 29)) ->x : Symbol(imp3.x, Decl(decls.ts, 8, 7)) +>x : Symbol(imp3.x, Decl(decls.ts, 7, 7)) var n: number; >n : Symbol(n, Decl(consumer.ts, 6, 3), Decl(consumer.ts, 7, 3)) === tests/cases/conformance/ambient/decls.ts === - // Ambient external module with export assignment declare module 'equ' { var x; ->x : Symbol(x, Decl(decls.ts, 3, 7)) +>x : Symbol(x, Decl(decls.ts, 2, 7)) export = x; ->x : Symbol(x, Decl(decls.ts, 3, 7)) +>x : Symbol(x, Decl(decls.ts, 2, 7)) } declare module 'equ2' { var x: number; ->x : Symbol(x, Decl(decls.ts, 8, 7)) +>x : Symbol(x, Decl(decls.ts, 7, 7)) } // Ambient external import declaration referencing ambient external module using top level module name diff --git a/tests/baselines/reference/ambientDeclarationsExternal.types b/tests/baselines/reference/ambientDeclarationsExternal.types index 062e006cf0a97..4cf7d6b0bcb60 100644 --- a/tests/baselines/reference/ambientDeclarationsExternal.types +++ b/tests/baselines/reference/ambientDeclarationsExternal.types @@ -18,7 +18,6 @@ var n: number; >n : number === tests/cases/conformance/ambient/decls.ts === - // Ambient external module with export assignment declare module 'equ' { var x; diff --git a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt index 4edf3bf7966f2..0757ba10e2e23 100644 --- a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt +++ b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(5,16): error TS2664: Invalid module name in augmentation, module 'ext' cannot be found. -tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(10,22): error TS2307: Cannot find module 'ext'. +tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(4,16): error TS2664: Invalid module name in augmentation, module 'ext' cannot be found. +tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(9,22): error TS2307: Cannot find module 'ext'. ==== tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts (2 errors) ==== - class D { } export = D; diff --git a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.js b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.js index b0382205cd3e7..0e5bb55036c79 100644 --- a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.js +++ b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.js @@ -1,5 +1,4 @@ //// [ambientExternalModuleInAnotherExternalModule.ts] - class D { } export = D; diff --git a/tests/baselines/reference/ambientGetters.errors.txt b/tests/baselines/reference/ambientGetters.errors.txt index a56020c41fbc0..b245f56181354 100644 --- a/tests/baselines/reference/ambientGetters.errors.txt +++ b/tests/baselines/reference/ambientGetters.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/ambientGetters.ts(3,9): error TS1086: An accessor cannot be declared in an ambient context. -tests/cases/compiler/ambientGetters.ts(7,9): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/ambientGetters.ts(2,9): error TS1086: An accessor cannot be declared in an ambient context. +tests/cases/compiler/ambientGetters.ts(6,9): error TS1086: An accessor cannot be declared in an ambient context. ==== tests/cases/compiler/ambientGetters.ts (2 errors) ==== - declare class A { get length() : number; ~~~~~~ diff --git a/tests/baselines/reference/ambientGetters.js b/tests/baselines/reference/ambientGetters.js index 9e267a1dddb15..db2310646afa8 100644 --- a/tests/baselines/reference/ambientGetters.js +++ b/tests/baselines/reference/ambientGetters.js @@ -1,5 +1,4 @@ //// [ambientGetters.ts] - declare class A { get length() : number; } diff --git a/tests/baselines/reference/ambientRequireFunction.js b/tests/baselines/reference/ambientRequireFunction.js index cd00b287c829a..348ee0a144389 100644 --- a/tests/baselines/reference/ambientRequireFunction.js +++ b/tests/baselines/reference/ambientRequireFunction.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/ambientRequireFunction.ts] //// //// [node.d.ts] - - declare function require(moduleName: string): any; declare module "fs" { diff --git a/tests/baselines/reference/ambientRequireFunction.symbols b/tests/baselines/reference/ambientRequireFunction.symbols index 6afb47e37fb0a..11f91a66357f8 100644 --- a/tests/baselines/reference/ambientRequireFunction.symbols +++ b/tests/baselines/reference/ambientRequireFunction.symbols @@ -4,24 +4,22 @@ const fs = require("fs"); >fs : Symbol(fs, Decl(app.js, 2, 5)) >require : Symbol(require, Decl(node.d.ts, 0, 0)) ->"fs" : Symbol("fs", Decl(node.d.ts, 2, 50)) +>"fs" : Symbol("fs", Decl(node.d.ts, 0, 50)) const text = fs.readFileSync("/a/b/c"); >text : Symbol(text, Decl(app.js, 3, 5)) ->fs.readFileSync : Symbol(readFileSync, Decl(node.d.ts, 4, 21)) +>fs.readFileSync : Symbol(readFileSync, Decl(node.d.ts, 2, 21)) >fs : Symbol(fs, Decl(app.js, 2, 5)) ->readFileSync : Symbol(readFileSync, Decl(node.d.ts, 4, 21)) +>readFileSync : Symbol(readFileSync, Decl(node.d.ts, 2, 21)) === tests/cases/compiler/node.d.ts === - - declare function require(moduleName: string): any; >require : Symbol(require, Decl(node.d.ts, 0, 0)) ->moduleName : Symbol(moduleName, Decl(node.d.ts, 2, 25)) +>moduleName : Symbol(moduleName, Decl(node.d.ts, 0, 25)) declare module "fs" { export function readFileSync(s: string): string; ->readFileSync : Symbol(readFileSync, Decl(node.d.ts, 4, 21)) ->s : Symbol(s, Decl(node.d.ts, 5, 33)) +>readFileSync : Symbol(readFileSync, Decl(node.d.ts, 2, 21)) +>s : Symbol(s, Decl(node.d.ts, 3, 33)) } diff --git a/tests/baselines/reference/ambientRequireFunction.types b/tests/baselines/reference/ambientRequireFunction.types index 7b01a59268fc3..5ae9a85188cf1 100644 --- a/tests/baselines/reference/ambientRequireFunction.types +++ b/tests/baselines/reference/ambientRequireFunction.types @@ -16,8 +16,6 @@ const text = fs.readFileSync("/a/b/c"); >"/a/b/c" : "/a/b/c" === tests/cases/compiler/node.d.ts === - - declare function require(moduleName: string): any; >require : (moduleName: string) => any >moduleName : string diff --git a/tests/baselines/reference/amdDependencyComment1.js b/tests/baselines/reference/amdDependencyComment1.js index 6be26909f3ad0..a11b65ff53fd8 100644 --- a/tests/baselines/reference/amdDependencyComment1.js +++ b/tests/baselines/reference/amdDependencyComment1.js @@ -5,8 +5,8 @@ import m1 = require("m2") m1.f(); //// [amdDependencyComment1.js] -/// "use strict"; +/// exports.__esModule = true; var m1 = require("m2"); m1.f(); diff --git a/tests/baselines/reference/amdDependencyCommentName1.js b/tests/baselines/reference/amdDependencyCommentName1.js index d0e4d73fb7a23..5065ed12ab4e2 100644 --- a/tests/baselines/reference/amdDependencyCommentName1.js +++ b/tests/baselines/reference/amdDependencyCommentName1.js @@ -5,8 +5,8 @@ import m1 = require("m2") m1.f(); //// [amdDependencyCommentName1.js] -/// "use strict"; +/// exports.__esModule = true; var m1 = require("m2"); m1.f(); diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt b/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt index d607ab65d2973..2a7be0262cf4b 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt +++ b/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/argumentsObjectIterator01_ES5.ts(4,21): error TS2495: Type 'IArguments' is not an array type or a string type. +tests/cases/compiler/argumentsObjectIterator01_ES5.ts(3,21): error TS2495: Type 'IArguments' is not an array type or a string type. ==== tests/cases/compiler/argumentsObjectIterator01_ES5.ts (1 errors) ==== - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let result = []; for (let arg of arguments) { diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES5.js b/tests/baselines/reference/argumentsObjectIterator01_ES5.js index 8378528dbf408..02b0a059a350b 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES5.js +++ b/tests/baselines/reference/argumentsObjectIterator01_ES5.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator01_ES5.ts] - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let result = []; for (let arg of arguments) { diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.js b/tests/baselines/reference/argumentsObjectIterator01_ES6.js index 03744f16b994b..ade88debd87cf 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES6.js +++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator01_ES6.ts] - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let result = []; for (let arg of arguments) { diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols index 384b4458b2fe3..aaa7431408bf9 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols +++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/argumentsObjectIterator01_ES6.ts === - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { >doubleAndReturnAsArray : Symbol(doubleAndReturnAsArray, Decl(argumentsObjectIterator01_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(argumentsObjectIterator01_ES6.ts, 1, 32)) ->y : Symbol(y, Decl(argumentsObjectIterator01_ES6.ts, 1, 42)) ->z : Symbol(z, Decl(argumentsObjectIterator01_ES6.ts, 1, 53)) +>x : Symbol(x, Decl(argumentsObjectIterator01_ES6.ts, 0, 32)) +>y : Symbol(y, Decl(argumentsObjectIterator01_ES6.ts, 0, 42)) +>z : Symbol(z, Decl(argumentsObjectIterator01_ES6.ts, 0, 53)) let result = []; ->result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 1, 7)) for (let arg of arguments) { ->arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 2, 12)) >arguments : Symbol(arguments) result.push(arg + arg); >result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 1, 7)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12)) ->arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 2, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 2, 12)) } return <[any, any, any]>result; ->result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 1, 7)) } diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.types b/tests/baselines/reference/argumentsObjectIterator01_ES6.types index 04e3bfe081fb2..a4f1b83896b97 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES6.types +++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/argumentsObjectIterator01_ES6.ts === - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { >doubleAndReturnAsArray : (x: number, y: number, z: number) => [number, number, number] >x : number diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt b/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt index 125f69b90b2fb..6e530bc49ff00 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt +++ b/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/argumentsObjectIterator02_ES5.ts(3,26): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/argumentsObjectIterator02_ES5.ts(2,26): error TS2304: Cannot find name 'Symbol'. ==== tests/cases/compiler/argumentsObjectIterator02_ES5.ts (1 errors) ==== - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let blah = arguments[Symbol.iterator]; ~~~~~~ diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES5.js b/tests/baselines/reference/argumentsObjectIterator02_ES5.js index 366bf8de199e7..ae8675d97453b 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES5.js +++ b/tests/baselines/reference/argumentsObjectIterator02_ES5.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator02_ES5.ts] - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let blah = arguments[Symbol.iterator]; diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.js b/tests/baselines/reference/argumentsObjectIterator02_ES6.js index 9b9415afd29a6..1155ab929eab5 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES6.js +++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator02_ES6.ts] - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { let blah = arguments[Symbol.iterator]; diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols index 974d668bc1f4c..64b82088e1a31 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols +++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/argumentsObjectIterator02_ES6.ts === - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { >doubleAndReturnAsArray : Symbol(doubleAndReturnAsArray, Decl(argumentsObjectIterator02_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(argumentsObjectIterator02_ES6.ts, 1, 32)) ->y : Symbol(y, Decl(argumentsObjectIterator02_ES6.ts, 1, 42)) ->z : Symbol(z, Decl(argumentsObjectIterator02_ES6.ts, 1, 53)) +>x : Symbol(x, Decl(argumentsObjectIterator02_ES6.ts, 0, 32)) +>y : Symbol(y, Decl(argumentsObjectIterator02_ES6.ts, 0, 42)) +>z : Symbol(z, Decl(argumentsObjectIterator02_ES6.ts, 0, 53)) let blah = arguments[Symbol.iterator]; ->blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7)) +>blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 1, 7)) >arguments : Symbol(arguments) >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) let result = []; ->result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 3, 7)) for (let arg of blah()) { ->arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12)) ->blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7)) +>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 4, 12)) +>blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 1, 7)) result.push(arg + arg); >result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 3, 7)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12)) ->arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 4, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 4, 12)) } return <[any, any, any]>result; ->result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7)) +>result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 3, 7)) } diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.types b/tests/baselines/reference/argumentsObjectIterator02_ES6.types index 3812107f3be52..a494a45f9356b 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES6.types +++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/argumentsObjectIterator02_ES6.ts === - function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { >doubleAndReturnAsArray : (x: number, y: number, z: number) => [number, number, number] >x : number diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt b/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt index c39ea23831766..d8e58482655f7 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt +++ b/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/argumentsObjectIterator03_ES5.ts(3,9): error TS2461: Type 'IArguments' is not an array type. +tests/cases/compiler/argumentsObjectIterator03_ES5.ts(2,9): error TS2461: Type 'IArguments' is not an array type. ==== tests/cases/compiler/argumentsObjectIterator03_ES5.ts (1 errors) ==== - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { let [x, y, z] = arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES5.js b/tests/baselines/reference/argumentsObjectIterator03_ES5.js index 7ea7e7b6593b6..837808a6d926d 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES5.js +++ b/tests/baselines/reference/argumentsObjectIterator03_ES5.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator03_ES5.ts] - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { let [x, y, z] = arguments; diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES6.js b/tests/baselines/reference/argumentsObjectIterator03_ES6.js index 788887e86eb1d..789bcc9390d51 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES6.js +++ b/tests/baselines/reference/argumentsObjectIterator03_ES6.js @@ -1,5 +1,4 @@ //// [argumentsObjectIterator03_ES6.ts] - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { let [x, y, z] = arguments; diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols index 97677123f3508..21ad6d052f1de 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols +++ b/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/argumentsObjectIterator03_ES6.ts === - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { >asReversedTuple : Symbol(asReversedTuple, Decl(argumentsObjectIterator03_ES6.ts, 0, 0)) ->a : Symbol(a, Decl(argumentsObjectIterator03_ES6.ts, 1, 25)) ->b : Symbol(b, Decl(argumentsObjectIterator03_ES6.ts, 1, 35)) ->c : Symbol(c, Decl(argumentsObjectIterator03_ES6.ts, 1, 46)) +>a : Symbol(a, Decl(argumentsObjectIterator03_ES6.ts, 0, 25)) +>b : Symbol(b, Decl(argumentsObjectIterator03_ES6.ts, 0, 35)) +>c : Symbol(c, Decl(argumentsObjectIterator03_ES6.ts, 0, 46)) let [x, y, z] = arguments; ->x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 2, 9)) ->y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 2, 11)) ->z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 2, 14)) +>x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 1, 9)) +>y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 1, 11)) +>z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 1, 14)) >arguments : Symbol(arguments) return [z, y, x]; ->z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 2, 14)) ->y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 2, 11)) ->x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 2, 9)) +>z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 1, 14)) +>y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 1, 11)) +>x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 1, 9)) } diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES6.types b/tests/baselines/reference/argumentsObjectIterator03_ES6.types index 95188dee0c8b3..5318f7692ea35 100644 --- a/tests/baselines/reference/argumentsObjectIterator03_ES6.types +++ b/tests/baselines/reference/argumentsObjectIterator03_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/argumentsObjectIterator03_ES6.ts === - function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { >asReversedTuple : (a: number, b: string, c: boolean) => [boolean, string, number] >a : number diff --git a/tests/baselines/reference/arrayAssignmentTest4.errors.txt b/tests/baselines/reference/arrayAssignmentTest4.errors.txt index ecded3a3bfd6d..0fb8112aa922a 100644 --- a/tests/baselines/reference/arrayAssignmentTest4.errors.txt +++ b/tests/baselines/reference/arrayAssignmentTest4.errors.txt @@ -1,12 +1,10 @@ -tests/cases/compiler/arrayAssignmentTest4.ts(24,1): error TS2322: Type '() => any' is not assignable to type 'any[]'. +tests/cases/compiler/arrayAssignmentTest4.ts(22,1): error TS2322: Type '() => any' is not assignable to type 'any[]'. Property 'push' is missing in type '() => any'. -tests/cases/compiler/arrayAssignmentTest4.ts(25,1): error TS2322: Type 'C3' is not assignable to type 'any[]'. +tests/cases/compiler/arrayAssignmentTest4.ts(23,1): error TS2322: Type 'C3' is not assignable to type 'any[]'. Property 'length' is missing in type 'C3'. ==== tests/cases/compiler/arrayAssignmentTest4.ts (2 errors) ==== - - class C3 { CM3M1() { return 3;} } diff --git a/tests/baselines/reference/arrayAssignmentTest4.js b/tests/baselines/reference/arrayAssignmentTest4.js index 6cc59bdece44a..31e826a06412f 100644 --- a/tests/baselines/reference/arrayAssignmentTest4.js +++ b/tests/baselines/reference/arrayAssignmentTest4.js @@ -1,6 +1,4 @@ //// [arrayAssignmentTest4.ts] - - class C3 { CM3M1() { return 3;} } diff --git a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.js b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.js index a6f01d7b75cad..916eee6218392 100644 --- a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.js +++ b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.js @@ -1,5 +1,4 @@ //// [arrayBindingPatternOmittedExpressions.ts] - var results: string[]; { diff --git a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols index 41d04ee623a05..82421e2ef30b3 100644 --- a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols +++ b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/arrayBindingPatternOmittedExpressions.ts === - var results: string[]; ->results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 1, 3)) +>results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 0, 3)) { let [, b, , a] = results; ->b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 4, 10)) ->a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 4, 15)) ->results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 1, 3)) +>b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 3, 10)) +>a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 3, 15)) +>results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 0, 3)) let x = { ->x : Symbol(x, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 7)) +>x : Symbol(x, Decl(arrayBindingPatternOmittedExpressions.ts, 4, 7)) a, ->a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 13)) +>a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 4, 13)) b ->b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 6, 10)) +>b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 10)) } } function f([, a, , b, , , , s, , , ] = results) { ->f : Symbol(f, Decl(arrayBindingPatternOmittedExpressions.ts, 9, 1)) ->a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 13)) ->b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 18)) ->s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 27)) ->results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 1, 3)) +>f : Symbol(f, Decl(arrayBindingPatternOmittedExpressions.ts, 8, 1)) +>a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 13)) +>b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 18)) +>s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 27)) +>results : Symbol(results, Decl(arrayBindingPatternOmittedExpressions.ts, 0, 3)) a = s[1]; ->a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 13)) ->s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 27)) +>a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 13)) +>s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 27)) b = s[2]; ->b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 18)) ->s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 12, 27)) +>b : Symbol(b, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 18)) +>s : Symbol(s, Decl(arrayBindingPatternOmittedExpressions.ts, 11, 27)) } diff --git a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.types b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.types index 38649f2b02d27..83cde401c229b 100644 --- a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.types +++ b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.types @@ -1,5 +1,4 @@ === tests/cases/compiler/arrayBindingPatternOmittedExpressions.ts === - var results: string[]; >results : string[] diff --git a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt index 6f4a0ef9d6df7..90dc909b11a93 100644 --- a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt +++ b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt @@ -8,7 +8,6 @@ tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error T Types of property 'concat' are incompatible. Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ >(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'. Type 'A[]' is not assignable to type 'B[]'. - Type 'A' is not assignable to type 'B'. ==== tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts (2 errors) ==== @@ -42,5 +41,4 @@ tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error T !!! error TS2322: Types of property 'concat' are incompatible. !!! error TS2322: Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ >(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'. !!! error TS2322: Type 'A[]' is not assignable to type 'B[]'. -!!! error TS2322: Type 'A' is not assignable to type 'B'. \ No newline at end of file diff --git a/tests/baselines/reference/arrowFunctionContexts.errors.txt b/tests/baselines/reference/arrowFunctionContexts.errors.txt index 461d84052d9a2..df158dec25e6e 100644 --- a/tests/baselines/reference/arrowFunctionContexts.errors.txt +++ b/tests/baselines/reference/arrowFunctionContexts.errors.txt @@ -1,17 +1,16 @@ -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(3,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(3,7): error TS2304: Cannot find name 'window'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(19,1): error TS2304: Cannot find name 'window'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(31,9): error TS2322: Type '() => number' is not assignable to type 'E'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(32,16): error TS2332: 'this' cannot be referenced in current location. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(44,5): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(44,11): error TS2304: Cannot find name 'window'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(60,5): error TS2304: Cannot find name 'window'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(72,13): error TS2322: Type '() => number' is not assignable to type 'E'. -tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(73,20): error TS2332: 'this' cannot be referenced in current location. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(2,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(2,7): error TS2304: Cannot find name 'window'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(18,1): error TS2304: Cannot find name 'window'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(30,9): error TS2322: Type '() => number' is not assignable to type 'E'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(31,16): error TS2332: 'this' cannot be referenced in current location. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(43,5): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(43,11): error TS2304: Cannot find name 'window'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(59,5): error TS2304: Cannot find name 'window'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(71,13): error TS2322: Type '() => number' is not assignable to type 'E'. +tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(72,20): error TS2332: 'this' cannot be referenced in current location. ==== tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts (10 errors) ==== - // Arrow function used in with statement with (window) { ~~~~~~~~~~~~~ diff --git a/tests/baselines/reference/arrowFunctionContexts.js b/tests/baselines/reference/arrowFunctionContexts.js index 2285aadd3d569..e2407db768a5c 100644 --- a/tests/baselines/reference/arrowFunctionContexts.js +++ b/tests/baselines/reference/arrowFunctionContexts.js @@ -1,5 +1,4 @@ //// [arrowFunctionContexts.ts] - // Arrow function used in with statement with (window) { var p = () => this; diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.js b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.js index daaff29cad927..6e38ade31413a 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.js +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.js @@ -1,5 +1,4 @@ //// [arrowFunctionWithParameterNameAsync_es2017.ts] - const x = async => async; //// [arrowFunctionWithParameterNameAsync_es2017.js] diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.symbols b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.symbols index 481697c0afdc9..2a4b1a95b58c3 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.symbols +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es2017.ts === - const x = async => async; ->x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 1, 5)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 1, 9)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 1, 9)) +>x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 0, 5)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 0, 9)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es2017.ts, 0, 9)) diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.types b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.types index ccb8654284c2e..5e9d0d089f242 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.types +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es2017.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es2017.ts === - const x = async => async; >x : (async: any) => any >async => async : (async: any) => any diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.js b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.js index df308028361ae..324121a1efb42 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.js +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.js @@ -1,5 +1,4 @@ //// [arrowFunctionWithParameterNameAsync_es5.ts] - const x = async => async; //// [arrowFunctionWithParameterNameAsync_es5.js] diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.symbols b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.symbols index 43c9c343efe7d..47a150ca02d42 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.symbols +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es5.ts === - const x = async => async; ->x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 1, 5)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 1, 9)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 1, 9)) +>x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 0, 5)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 0, 9)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es5.ts, 0, 9)) diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.types b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.types index bd567320f1d3f..af963d2be0497 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.types +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es5.ts === - const x = async => async; >x : (async: any) => any >async => async : (async: any) => any diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.js b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.js index 8527fefc50db9..a3b69bcab67cf 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.js +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.js @@ -1,5 +1,4 @@ //// [arrowFunctionWithParameterNameAsync_es6.ts] - const x = async => async; //// [arrowFunctionWithParameterNameAsync_es6.js] diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.symbols b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.symbols index 73e5f31aeb3d0..102ea23fc39a1 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.symbols +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es6.ts === - const x = async => async; ->x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 1, 5)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 1, 9)) ->async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 1, 9)) +>x : Symbol(x, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 0, 5)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 0, 9)) +>async : Symbol(async, Decl(arrowFunctionWithParameterNameAsync_es6.ts, 0, 9)) diff --git a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.types b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.types index b6a19fe30edca..8502a206f4ae9 100644 --- a/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.types +++ b/tests/baselines/reference/arrowFunctionWithParameterNameAsync_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es6.ts === - const x = async => async; >x : (async: any) => any >async => async : (async: any) => any diff --git a/tests/baselines/reference/arrowFunctionsMissingTokens.errors.txt b/tests/baselines/reference/arrowFunctionsMissingTokens.errors.txt index ee87a6b8dd477..988a98c32809c 100644 --- a/tests/baselines/reference/arrowFunctionsMissingTokens.errors.txt +++ b/tests/baselines/reference/arrowFunctionsMissingTokens.errors.txt @@ -1,31 +1,30 @@ -tests/cases/compiler/arrowFunctionsMissingTokens.ts(3,16): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(5,22): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(7,17): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(9,36): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(11,42): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(16,23): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(18,29): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(20,24): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(22,43): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(24,49): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(26,23): error TS1005: '{' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(30,23): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(32,29): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(34,24): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(36,43): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(38,49): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(40,23): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(41,5): error TS1128: Declaration or statement expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(42,1): error TS1128: Declaration or statement expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(45,14): error TS1109: Expression expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(47,21): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(49,14): error TS2304: Cannot find name 'x'. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(51,35): error TS1005: '=>' expected. -tests/cases/compiler/arrowFunctionsMissingTokens.ts(53,41): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(2,16): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(4,22): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(6,17): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(8,36): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(10,42): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(15,23): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(17,29): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(19,24): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(21,43): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(23,49): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(25,23): error TS1005: '{' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(29,23): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(31,29): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(33,24): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(35,43): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(37,49): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(39,23): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(40,5): error TS1128: Declaration or statement expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(41,1): error TS1128: Declaration or statement expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(44,14): error TS1109: Expression expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(46,21): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(48,14): error TS2304: Cannot find name 'x'. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(50,35): error TS1005: '=>' expected. +tests/cases/compiler/arrowFunctionsMissingTokens.ts(52,41): error TS1005: '=>' expected. ==== tests/cases/compiler/arrowFunctionsMissingTokens.ts (24 errors) ==== - module missingArrowsWithCurly { var a = () { }; ~ diff --git a/tests/baselines/reference/arrowFunctionsMissingTokens.js b/tests/baselines/reference/arrowFunctionsMissingTokens.js index ef4476f6e455e..d0a8bde2a5365 100644 --- a/tests/baselines/reference/arrowFunctionsMissingTokens.js +++ b/tests/baselines/reference/arrowFunctionsMissingTokens.js @@ -1,5 +1,4 @@ //// [arrowFunctionsMissingTokens.ts] - module missingArrowsWithCurly { var a = () { }; diff --git a/tests/baselines/reference/asOperator4.js b/tests/baselines/reference/asOperator4.js index 3a43f328f3511..d0eac5bb1137b 100644 --- a/tests/baselines/reference/asOperator4.js +++ b/tests/baselines/reference/asOperator4.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/expressions/asOperator/asOperator4.ts] //// //// [foo.ts] - export function foo() { } //// [bar.ts] diff --git a/tests/baselines/reference/asOperator4.symbols b/tests/baselines/reference/asOperator4.symbols index 4ee5f6fe83fd2..276c0706069cd 100644 --- a/tests/baselines/reference/asOperator4.symbols +++ b/tests/baselines/reference/asOperator4.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/asOperator/foo.ts === - export function foo() { } >foo : Symbol(foo, Decl(foo.ts, 0, 0)) diff --git a/tests/baselines/reference/asOperator4.types b/tests/baselines/reference/asOperator4.types index 0dc6be46a2c2e..c60cfc19e3299 100644 --- a/tests/baselines/reference/asOperator4.types +++ b/tests/baselines/reference/asOperator4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/asOperator/foo.ts === - export function foo() { } >foo : () => void diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.js b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.js index caf90acae5fa7..40ec54d0ac51c 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.js +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsAmbientExternalModule01.ts] - var declare: number; var module: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.symbols b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.symbols index c35432b7eceab..87e75ef0d0010 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.symbols @@ -1,16 +1,15 @@ === tests/cases/conformance/externalModules/asiPreventsParsingAsAmbientExternalModule01.ts === - var declare: number; ->declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 0, 3)) var module: string; ->module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 2, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 1, 3)) declare // this is the identifier 'declare' ->declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 0, 3)) module // this is the identifier 'module' ->module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 2, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule01.ts, 1, 3)) "my external module" // this is just a string { } // this is a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.types b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.types index 744687429ce14..1b690aee048f7 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.types +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/externalModules/asiPreventsParsingAsAmbientExternalModule01.ts === - var declare: number; >declare : number diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.js b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.js index 20e2693ba7f19..74cd41de62237 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.js +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsAmbientExternalModule02.ts] - var declare: number; var module: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.symbols b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.symbols index ed97f39fc11d0..ecc5728b32f8c 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/externalModules/asiPreventsParsingAsAmbientExternalModule02.ts === - var declare: number; ->declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 0, 3)) var module: string; ->module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 2, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 3)) module container { ->container : Symbol(container, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 2, 19)) +>container : Symbol(container, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 19)) declare // this is the identifier 'declare' ->declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 0, 3)) module // this is the identifier 'module' ->module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 2, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsAmbientExternalModule02.ts, 1, 3)) "my external module" // this is just a string { } // this is a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.types b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.types index ae82f5f68a458..d4c769fa50a7d 100644 --- a/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.types +++ b/tests/baselines/reference/asiPreventsParsingAsAmbientExternalModule02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/externalModules/asiPreventsParsingAsAmbientExternalModule02.ts === - var declare: number; >declare : number diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface01.js b/tests/baselines/reference/asiPreventsParsingAsInterface01.js index 024ad54371f3d..4d0215454b6c4 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface01.js +++ b/tests/baselines/reference/asiPreventsParsingAsInterface01.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsInterface01.ts] - var interface: number, I: string; interface // This should be the identifier 'interface' diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface01.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface01.symbols index d92c13e8ceb56..b353c406cc6b6 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface01.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsInterface01.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface01.ts === - var interface: number, I: string; ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface01.ts, 1, 3)) ->I : Symbol(I, Decl(asiPreventsParsingAsInterface01.ts, 1, 22)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface01.ts, 0, 3)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface01.ts, 0, 22)) interface // This should be the identifier 'interface' ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface01.ts, 1, 3)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface01.ts, 0, 3)) I // This should be the identifier 'I' ->I : Symbol(I, Decl(asiPreventsParsingAsInterface01.ts, 1, 22)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface01.ts, 0, 22)) {} // This should be a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface01.types b/tests/baselines/reference/asiPreventsParsingAsInterface01.types index 03c1b9fc41252..101b2c8f96b50 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface01.types +++ b/tests/baselines/reference/asiPreventsParsingAsInterface01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface01.ts === - var interface: number, I: string; >interface : number >I : string diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface02.js b/tests/baselines/reference/asiPreventsParsingAsInterface02.js index 0ea0421550ad0..d38cc228d2e57 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface02.js +++ b/tests/baselines/reference/asiPreventsParsingAsInterface02.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsInterface02.ts] - function f(interface: number, I: string) { interface // This should be the identifier 'interface' I // This should be the identifier 'I' diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface02.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface02.symbols index e1e4febe38c6f..ea22e5f24b3ef 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface02.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsInterface02.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface02.ts === - function f(interface: number, I: string) { >f : Symbol(f, Decl(asiPreventsParsingAsInterface02.ts, 0, 0)) ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface02.ts, 1, 11)) ->I : Symbol(I, Decl(asiPreventsParsingAsInterface02.ts, 1, 29)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface02.ts, 0, 11)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface02.ts, 0, 29)) interface // This should be the identifier 'interface' ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface02.ts, 1, 11)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface02.ts, 0, 11)) I // This should be the identifier 'I' ->I : Symbol(I, Decl(asiPreventsParsingAsInterface02.ts, 1, 29)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface02.ts, 0, 29)) {} // This should be a block body } diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface02.types b/tests/baselines/reference/asiPreventsParsingAsInterface02.types index 7989cc810a817..5477fd1c0719f 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface02.types +++ b/tests/baselines/reference/asiPreventsParsingAsInterface02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface02.ts === - function f(interface: number, I: string) { >f : (interface: number, I: string) => void >interface : number diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface03.js b/tests/baselines/reference/asiPreventsParsingAsInterface03.js index 3b3c836f7f46b..b35c94de5b2e9 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface03.js +++ b/tests/baselines/reference/asiPreventsParsingAsInterface03.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsInterface03.ts] - var interface: number, I: string; namespace n { diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface03.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface03.symbols index e8c95cf1244de..25d220dec6a7c 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface03.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsInterface03.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface03.ts === - var interface: number, I: string; ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface03.ts, 1, 3)) ->I : Symbol(I, Decl(asiPreventsParsingAsInterface03.ts, 1, 22)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface03.ts, 0, 3)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface03.ts, 0, 22)) namespace n { ->n : Symbol(n, Decl(asiPreventsParsingAsInterface03.ts, 1, 33)) +>n : Symbol(n, Decl(asiPreventsParsingAsInterface03.ts, 0, 33)) interface // This should be the identifier 'interface' ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface03.ts, 1, 3)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface03.ts, 0, 3)) I // This should be the identifier 'I' ->I : Symbol(I, Decl(asiPreventsParsingAsInterface03.ts, 1, 22)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface03.ts, 0, 22)) {} // This should be a block body } diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface03.types b/tests/baselines/reference/asiPreventsParsingAsInterface03.types index a58d502fc256a..23c90ad8cce22 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface03.types +++ b/tests/baselines/reference/asiPreventsParsingAsInterface03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface03.ts === - var interface: number, I: string; >interface : number >I : string diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface04.js b/tests/baselines/reference/asiPreventsParsingAsInterface04.js index 1700636e5225f..1c39f09d59694 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface04.js +++ b/tests/baselines/reference/asiPreventsParsingAsInterface04.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsInterface04.ts] - var declare: boolean, interface: number, I: string; declare // This should be the identifier 'declare' diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface04.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface04.symbols index 094411ebed5da..e7e91ffd3c534 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface04.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsInterface04.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface04.ts === - var declare: boolean, interface: number, I: string; ->declare : Symbol(declare, Decl(asiPreventsParsingAsInterface04.ts, 1, 3)) ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface04.ts, 1, 21)) ->I : Symbol(I, Decl(asiPreventsParsingAsInterface04.ts, 1, 40)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsInterface04.ts, 0, 3)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface04.ts, 0, 21)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface04.ts, 0, 40)) declare // This should be the identifier 'declare' ->declare : Symbol(declare, Decl(asiPreventsParsingAsInterface04.ts, 1, 3)) +>declare : Symbol(declare, Decl(asiPreventsParsingAsInterface04.ts, 0, 3)) interface // This should be the identifier 'interface' ->interface : Symbol(interface, Decl(asiPreventsParsingAsInterface04.ts, 1, 21)) +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface04.ts, 0, 21)) I // This should be the identifier 'I' ->I : Symbol(I, Decl(asiPreventsParsingAsInterface04.ts, 1, 40)) +>I : Symbol(I, Decl(asiPreventsParsingAsInterface04.ts, 0, 40)) {} // This should be a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface04.types b/tests/baselines/reference/asiPreventsParsingAsInterface04.types index f6d29749ae16e..d616eccf6e01d 100644 --- a/tests/baselines/reference/asiPreventsParsingAsInterface04.types +++ b/tests/baselines/reference/asiPreventsParsingAsInterface04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface04.ts === - var declare: boolean, interface: number, I: string; >declare : boolean >interface : number diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace01.js b/tests/baselines/reference/asiPreventsParsingAsNamespace01.js index 282d9dd1c7cd1..f471b93e3c9a8 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace01.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace01.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace01.ts] - var namespace: number; var n: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace01.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace01.symbols index b196d73335206..70c53a50611ea 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace01.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace01.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace01.ts === - var namespace: number; ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace01.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace01.ts, 0, 3)) var n: string; ->n : Symbol(n, Decl(asiPreventsParsingAsNamespace01.ts, 2, 3)) +>n : Symbol(n, Decl(asiPreventsParsingAsNamespace01.ts, 1, 3)) namespace // this is the identifier 'namespace' ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace01.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace01.ts, 0, 3)) n // this is the identifier 'n' ->n : Symbol(n, Decl(asiPreventsParsingAsNamespace01.ts, 2, 3)) +>n : Symbol(n, Decl(asiPreventsParsingAsNamespace01.ts, 1, 3)) { } // this is a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace01.types b/tests/baselines/reference/asiPreventsParsingAsNamespace01.types index 417a96dbed41c..5fbee41f3f281 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace01.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace01.ts === - var namespace: number; >namespace : number diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace02.js b/tests/baselines/reference/asiPreventsParsingAsNamespace02.js index 514a026dc78d0..c3a09147a9b56 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace02.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace02.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace02.ts] - var module: number; var m: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace02.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace02.symbols index a3bb37c73bcae..019e54bc41598 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace02.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace02.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace02.ts === - var module: number; ->module : Symbol(module, Decl(asiPreventsParsingAsNamespace02.ts, 1, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsNamespace02.ts, 0, 3)) var m: string; ->m : Symbol(m, Decl(asiPreventsParsingAsNamespace02.ts, 2, 3)) +>m : Symbol(m, Decl(asiPreventsParsingAsNamespace02.ts, 1, 3)) module // this is the identifier 'namespace' ->module : Symbol(module, Decl(asiPreventsParsingAsNamespace02.ts, 1, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsNamespace02.ts, 0, 3)) m // this is the identifier 'm' ->m : Symbol(m, Decl(asiPreventsParsingAsNamespace02.ts, 2, 3)) +>m : Symbol(m, Decl(asiPreventsParsingAsNamespace02.ts, 1, 3)) { } // this is a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace02.types b/tests/baselines/reference/asiPreventsParsingAsNamespace02.types index e9e1433be7a03..efc95969ecc7b 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace02.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace02.ts === - var module: number; >module : number diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace03.js b/tests/baselines/reference/asiPreventsParsingAsNamespace03.js index 3c27694f5ceeb..306ad1baf494d 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace03.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace03.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace03.ts] - var namespace: number; var n: string; diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace03.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace03.symbols index e77d012a1bf6e..8cd929e1986d0 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace03.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace03.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace03.ts === - var namespace: number; ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace03.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace03.ts, 0, 3)) var n: string; ->n : Symbol(n, Decl(asiPreventsParsingAsNamespace03.ts, 2, 3)) +>n : Symbol(n, Decl(asiPreventsParsingAsNamespace03.ts, 1, 3)) namespace container { ->container : Symbol(container, Decl(asiPreventsParsingAsNamespace03.ts, 2, 14)) +>container : Symbol(container, Decl(asiPreventsParsingAsNamespace03.ts, 1, 14)) namespace // this is the identifier 'namespace' ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace03.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace03.ts, 0, 3)) n // this is the identifier 'n' ->n : Symbol(n, Decl(asiPreventsParsingAsNamespace03.ts, 2, 3)) +>n : Symbol(n, Decl(asiPreventsParsingAsNamespace03.ts, 1, 3)) { } // this is a block body } diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace03.types b/tests/baselines/reference/asiPreventsParsingAsNamespace03.types index f119a789e11c3..918383e4cb1c0 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace03.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace03.ts === - var namespace: number; >namespace : number diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace04.js b/tests/baselines/reference/asiPreventsParsingAsNamespace04.js index 704c8893e767c..b8de05cf86053 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace04.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace04.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace04.ts] - let module = 10; module in {} diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols index 60d1f8fcc48ff..fcacb36dba149 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace04.ts === - let module = 10; ->module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 1, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 0, 3)) module in {} ->module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 1, 3)) +>module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 0, 3)) diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace04.types b/tests/baselines/reference/asiPreventsParsingAsNamespace04.types index 7cab2a7be3640..0492d79e9a58f 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace04.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace04.ts === - let module = 10; >module : number >10 : 10 diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace05.js b/tests/baselines/reference/asiPreventsParsingAsNamespace05.js index 35f557328c0e8..d7cab5ae28336 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace05.js +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace05.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsNamespace05.ts] - let namespace = 10; namespace a.b { export let c = 20; diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace05.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace05.symbols index 47f05862b0a6c..35e69ef56f8fe 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace05.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace05.symbols @@ -1,24 +1,23 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace05.ts === - let namespace = 10; ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace05.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace05.ts, 0, 3)) namespace a.b { ->a : Symbol(a, Decl(asiPreventsParsingAsNamespace05.ts, 1, 19)) ->b : Symbol(b, Decl(asiPreventsParsingAsNamespace05.ts, 2, 12)) +>a : Symbol(a, Decl(asiPreventsParsingAsNamespace05.ts, 0, 19)) +>b : Symbol(b, Decl(asiPreventsParsingAsNamespace05.ts, 1, 12)) export let c = 20; ->c : Symbol(c, Decl(asiPreventsParsingAsNamespace05.ts, 3, 14)) +>c : Symbol(c, Decl(asiPreventsParsingAsNamespace05.ts, 2, 14)) } namespace ->namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace05.ts, 1, 3)) +>namespace : Symbol(namespace, Decl(asiPreventsParsingAsNamespace05.ts, 0, 3)) a.b.c ->a.b.c : Symbol(a.b.c, Decl(asiPreventsParsingAsNamespace05.ts, 3, 14)) ->a.b : Symbol(a.b, Decl(asiPreventsParsingAsNamespace05.ts, 2, 12)) ->a : Symbol(a, Decl(asiPreventsParsingAsNamespace05.ts, 1, 19)) ->b : Symbol(a.b, Decl(asiPreventsParsingAsNamespace05.ts, 2, 12)) ->c : Symbol(a.b.c, Decl(asiPreventsParsingAsNamespace05.ts, 3, 14)) +>a.b.c : Symbol(a.b.c, Decl(asiPreventsParsingAsNamespace05.ts, 2, 14)) +>a.b : Symbol(a.b, Decl(asiPreventsParsingAsNamespace05.ts, 1, 12)) +>a : Symbol(a, Decl(asiPreventsParsingAsNamespace05.ts, 0, 19)) +>b : Symbol(a.b, Decl(asiPreventsParsingAsNamespace05.ts, 1, 12)) +>c : Symbol(a.b.c, Decl(asiPreventsParsingAsNamespace05.ts, 2, 14)) { } diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace05.types b/tests/baselines/reference/asiPreventsParsingAsNamespace05.types index e1492c8c582a8..98e94c9dc2794 100644 --- a/tests/baselines/reference/asiPreventsParsingAsNamespace05.types +++ b/tests/baselines/reference/asiPreventsParsingAsNamespace05.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/moduleDeclarations/asiPreventsParsingAsNamespace05.ts === - let namespace = 10; >namespace : number >10 : 10 diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.js b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.js index b05988290cb1f..7a7ec322eead8 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.js +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsTypeAlias01.ts] - var type; var string; var Foo; diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.symbols b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.symbols index fa82d53ac70ec..eaf10d109d328 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.symbols @@ -1,18 +1,17 @@ === tests/cases/conformance/types/typeAliases/asiPreventsParsingAsTypeAlias01.ts === - var type; ->type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias01.ts, 1, 3)) +>type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias01.ts, 0, 3)) var string; ->string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias01.ts, 2, 3)) +>string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias01.ts, 1, 3)) var Foo; ->Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias01.ts, 3, 3)) +>Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias01.ts, 2, 3)) type ->type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias01.ts, 1, 3)) +>type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias01.ts, 0, 3)) Foo = string; ->Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias01.ts, 3, 3)) ->string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias01.ts, 2, 3)) +>Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias01.ts, 2, 3)) +>string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias01.ts, 1, 3)) diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.types b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.types index 7492a698e3a26..2c3d1f8091226 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.types +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeAliases/asiPreventsParsingAsTypeAlias01.ts === - var type; >type : any diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.js b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.js index eae9898c8d409..db6215388ffa7 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.js +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.js @@ -1,5 +1,4 @@ //// [asiPreventsParsingAsTypeAlias02.ts] - var type; var string; var Foo; diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.symbols b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.symbols index 4b83dba4c5d25..23761438119d8 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.symbols +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.symbols @@ -1,21 +1,20 @@ === tests/cases/conformance/types/typeAliases/asiPreventsParsingAsTypeAlias02.ts === - var type; ->type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias02.ts, 1, 3)) +>type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias02.ts, 0, 3)) var string; ->string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 3)) +>string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias02.ts, 1, 3)) var Foo; ->Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias02.ts, 3, 3)) +>Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 3)) namespace container { ->container : Symbol(container, Decl(asiPreventsParsingAsTypeAlias02.ts, 3, 8)) +>container : Symbol(container, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 8)) type ->type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias02.ts, 1, 3)) +>type : Symbol(type, Decl(asiPreventsParsingAsTypeAlias02.ts, 0, 3)) Foo = string; ->Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias02.ts, 3, 3)) ->string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 3)) +>Foo : Symbol(Foo, Decl(asiPreventsParsingAsTypeAlias02.ts, 2, 3)) +>string : Symbol(string, Decl(asiPreventsParsingAsTypeAlias02.ts, 1, 3)) } diff --git a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.types b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.types index 1e6c7a8caf1a6..62e71637127f4 100644 --- a/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.types +++ b/tests/baselines/reference/asiPreventsParsingAsTypeAlias02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeAliases/asiPreventsParsingAsTypeAlias02.ts === - var type; >type : any diff --git a/tests/baselines/reference/asyncArrowFunction10_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es2017.errors.txt index 923dbed6dad93..45ae071639cd7 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction10_es2017.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017.ts(4,11): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017.ts(3,11): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017.ts (1 errors) ==== - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es2017.js b/tests/baselines/reference/asyncArrowFunction10_es2017.js index 3c966201bc20c..3fd29302a36da 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction10_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction10_es2017.ts] - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es5.errors.txt index 0b3596282ff2c..5b4505ebfde2e 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction10_es5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction10_es5.ts(4,11): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction10_es5.ts(3,11): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction10_es5.ts (1 errors) ==== - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es5.js b/tests/baselines/reference/asyncArrowFunction10_es5.js index 2fc2ac56f9f12..5fc37de5f1873 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es5.js +++ b/tests/baselines/reference/asyncArrowFunction10_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction10_es5.ts] - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt index b5ea2a9d926c4..a5a6b45b45b10 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(4,11): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(3,11): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts (1 errors) ==== - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.js b/tests/baselines/reference/asyncArrowFunction10_es6.js index 301e41544bbc9..78c8b64327f80 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es6.js +++ b/tests/baselines/reference/asyncArrowFunction10_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction10_es6.ts] - var foo = async (): Promise => { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/baselines/reference/asyncArrowFunction1_es2017.js b/tests/baselines/reference/asyncArrowFunction1_es2017.js index ff6a4624242bd..b946bc99428fb 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction1_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction1_es2017.ts] - var foo = async (): Promise => { }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es2017.symbols b/tests/baselines/reference/asyncArrowFunction1_es2017.symbols index 239a057aa8832..15739132d3500 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es2017.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es2017.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction1_es2017.ts === - var foo = async (): Promise => { ->foo : Symbol(foo, Decl(asyncArrowFunction1_es2017.ts, 1, 3)) +>foo : Symbol(foo, Decl(asyncArrowFunction1_es2017.ts, 0, 3)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es2017.types b/tests/baselines/reference/asyncArrowFunction1_es2017.types index bdc6cacc91704..3f2c057e61f73 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es2017.types +++ b/tests/baselines/reference/asyncArrowFunction1_es2017.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction1_es2017.ts === - var foo = async (): Promise => { >foo : () => Promise >async (): Promise => {} : () => Promise diff --git a/tests/baselines/reference/asyncArrowFunction1_es5.js b/tests/baselines/reference/asyncArrowFunction1_es5.js index aac185c63a1e5..e26770d8fe9b2 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es5.js +++ b/tests/baselines/reference/asyncArrowFunction1_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction1_es5.ts] - var foo = async (): Promise => { }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es5.symbols b/tests/baselines/reference/asyncArrowFunction1_es5.symbols index 9f09c3ac9adcf..914165f525baa 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es5.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es5.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction1_es5.ts === - var foo = async (): Promise => { ->foo : Symbol(foo, Decl(asyncArrowFunction1_es5.ts, 1, 3)) +>foo : Symbol(foo, Decl(asyncArrowFunction1_es5.ts, 0, 3)) >Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es5.types b/tests/baselines/reference/asyncArrowFunction1_es5.types index bde82d2b83603..062cfd889747c 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es5.types +++ b/tests/baselines/reference/asyncArrowFunction1_es5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction1_es5.ts === - var foo = async (): Promise => { >foo : () => Promise >async (): Promise => {} : () => Promise diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.js b/tests/baselines/reference/asyncArrowFunction1_es6.js index 0026cd91a7ef9..202864364f3e6 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.js +++ b/tests/baselines/reference/asyncArrowFunction1_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction1_es6.ts] - var foo = async (): Promise => { }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols index bc3557865ee04..2ef65441ff9e3 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts === - var foo = async (): Promise => { ->foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3)) +>foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 0, 3)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.types b/tests/baselines/reference/asyncArrowFunction1_es6.types index 3ecfdeb79191a..f3c5d0887f1b3 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.types +++ b/tests/baselines/reference/asyncArrowFunction1_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts === - var foo = async (): Promise => { >foo : () => Promise >async (): Promise => {} : () => Promise diff --git a/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt index 3df5617710712..a2504b35e684f 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,11): error TS2304: Cannot find name 'async'. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,18): error TS2304: Cannot find name 'await'. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,24): error TS1005: ',' expected. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,33): error TS1005: '=' expected. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(2,40): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,18): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,24): error TS1005: ',' expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,33): error TS1005: '=' expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts(1,40): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts (6 errors) ==== - var foo = async (await): Promise => { ~~~~~ !!! error TS2304: Cannot find name 'async'. diff --git a/tests/baselines/reference/asyncArrowFunction5_es2017.js b/tests/baselines/reference/asyncArrowFunction5_es2017.js index 0c61a141f176c..b12d06e6e328e 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction5_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction5_es2017.ts] - var foo = async (await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt index e19113e66f85f..a54794747faa7 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,11): error TS2304: Cannot find name 'async'. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,18): error TS2304: Cannot find name 'await'. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,24): error TS1005: ',' expected. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,33): error TS1005: '=' expected. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(2,40): error TS1109: Expression expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,18): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,24): error TS1005: ',' expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,33): error TS1005: '=' expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(1,40): error TS1109: Expression expected. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts (6 errors) ==== - var foo = async (await): Promise => { ~~~~~ !!! error TS2304: Cannot find name 'async'. diff --git a/tests/baselines/reference/asyncArrowFunction5_es5.js b/tests/baselines/reference/asyncArrowFunction5_es5.js index ff5ee68d4c7ab..2e15f99e2975b 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es5.js +++ b/tests/baselines/reference/asyncArrowFunction5_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction5_es5.ts] - var foo = async (await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt index fed2962053245..aec8e36fae87a 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,11): error TS2304: Cannot find name 'async'. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,18): error TS2304: Cannot find name 'await'. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,24): error TS1005: ',' expected. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,33): error TS1005: '=' expected. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,40): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,18): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,24): error TS1005: ',' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,33): error TS1005: '=' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,40): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts (6 errors) ==== - var foo = async (await): Promise => { ~~~~~ !!! error TS2304: Cannot find name 'async'. diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.js b/tests/baselines/reference/asyncArrowFunction5_es6.js index ed4035e61754c..b5ae55a8f4842 100644 --- a/tests/baselines/reference/asyncArrowFunction5_es6.js +++ b/tests/baselines/reference/asyncArrowFunction5_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction5_es6.ts] - var foo = async (await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction6_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es2017.errors.txt index 202ecb1727fd5..9e35d990b1f39 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction6_es2017.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts(2,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts(2,27): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts(1,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts(1,27): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts (2 errors) ==== - var foo = async (a = await): Promise => { ~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. diff --git a/tests/baselines/reference/asyncArrowFunction6_es2017.js b/tests/baselines/reference/asyncArrowFunction6_es2017.js index c36f75a180a76..129460e868bd1 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction6_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction6_es2017.ts] - var foo = async (a = await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction6_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es5.errors.txt index a957589bd945e..9d0dbd748807a 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction6_es5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts(2,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts(2,27): error TS1109: Expression expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts(1,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts(1,27): error TS1109: Expression expected. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts (2 errors) ==== - var foo = async (a = await): Promise => { ~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. diff --git a/tests/baselines/reference/asyncArrowFunction6_es5.js b/tests/baselines/reference/asyncArrowFunction6_es5.js index ea61a1b44b5cb..fe91930a1566c 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es5.js +++ b/tests/baselines/reference/asyncArrowFunction6_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction6_es5.ts] - var foo = async (a = await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt index 111e4ff46d095..269fc60962f8f 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,27): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(1,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(1,27): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts (2 errors) ==== - var foo = async (a = await): Promise => { ~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js index a01e53f5b114f..345764a688cf7 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.js +++ b/tests/baselines/reference/asyncArrowFunction6_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction6_es6.ts] - var foo = async (a = await): Promise => { } diff --git a/tests/baselines/reference/asyncArrowFunction7_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es2017.errors.txt index 33e03624283e6..848ceb497f27f 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction7_es2017.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts(4,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts(4,29): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts(3,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts(3,29): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts (2 errors) ==== - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es2017.js b/tests/baselines/reference/asyncArrowFunction7_es2017.js index 11d8c879eb8bd..05c78887561c9 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction7_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction7_es2017.ts] - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es5.errors.txt index cc5cf2bb61dda..5d4f03cbc41b8 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction7_es5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts(4,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts(4,29): error TS1109: Expression expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts(3,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts(3,29): error TS1109: Expression expected. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts (2 errors) ==== - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es5.js b/tests/baselines/reference/asyncArrowFunction7_es5.js index f2edb2b653728..b93966443ab75 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es5.js +++ b/tests/baselines/reference/asyncArrowFunction7_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction7_es5.ts] - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt index 6376626d0e717..f37598985c72c 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,29): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(3,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(3,29): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts (2 errors) ==== - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js index fab705c0b76e2..45d9cb3643a29 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.js +++ b/tests/baselines/reference/asyncArrowFunction7_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction7_es6.ts] - var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { diff --git a/tests/baselines/reference/asyncArrowFunction8_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction8_es2017.errors.txt index 75e460490bd85..d5fdfbef24d6a 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es2017.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction8_es2017.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction8_es2017.ts(3,19): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction8_es2017.ts(2,19): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction8_es2017.ts (1 errors) ==== - var foo = async (): Promise => { var v = { [await]: foo } ~ diff --git a/tests/baselines/reference/asyncArrowFunction8_es2017.js b/tests/baselines/reference/asyncArrowFunction8_es2017.js index 1358f186ce221..d5253c8b689ce 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es2017.js +++ b/tests/baselines/reference/asyncArrowFunction8_es2017.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction8_es2017.ts] - var foo = async (): Promise => { var v = { [await]: foo } } diff --git a/tests/baselines/reference/asyncArrowFunction8_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction8_es5.errors.txt index e2e69fc5bee65..620d0b5653b7c 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es5.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction8_es5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction8_es5.ts(3,19): error TS1109: Expression expected. +tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction8_es5.ts(2,19): error TS1109: Expression expected. ==== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction8_es5.ts (1 errors) ==== - var foo = async (): Promise => { var v = { [await]: foo } ~ diff --git a/tests/baselines/reference/asyncArrowFunction8_es5.js b/tests/baselines/reference/asyncArrowFunction8_es5.js index 3043294926252..26153a5943631 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es5.js +++ b/tests/baselines/reference/asyncArrowFunction8_es5.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction8_es5.ts] - var foo = async (): Promise => { var v = { [await]: foo } } diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt index 7252805cdcac7..7105311b06fca 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts(3,19): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts(2,19): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts (1 errors) ==== - var foo = async (): Promise => { var v = { [await]: foo } ~ diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.js b/tests/baselines/reference/asyncArrowFunction8_es6.js index 0c33cfcfa2de0..51ec4318c0a8a 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es6.js +++ b/tests/baselines/reference/asyncArrowFunction8_es6.js @@ -1,5 +1,4 @@ //// [asyncArrowFunction8_es6.ts] - var foo = async (): Promise => { var v = { [await]: foo } } diff --git a/tests/baselines/reference/asyncFunctionWithForStatementNoInitializer.js b/tests/baselines/reference/asyncFunctionWithForStatementNoInitializer.js new file mode 100644 index 0000000000000..10f6c20eb06b7 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionWithForStatementNoInitializer.js @@ -0,0 +1,106 @@ +//// [asyncFunctionWithForStatementNoInitializer.ts] +async function test1() { + let i = 0 + let limit = 10 + for (; i < limit; ++i) { + } +} + +async function test2() { + let i = 0 + let limit = 10 + for (i = 1; i < limit; ++i) { + } +} + +async function test3() { + let i = 0 + for (;; ++i) { + } +} + +async function test4() { + for (;;) { + } +} + +//// [asyncFunctionWithForStatementNoInitializer.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +function test1() { + return __awaiter(this, void 0, void 0, function () { + var i, limit; + return __generator(this, function (_a) { + i = 0; + limit = 10; + for (; i < limit; ++i) { + } + return [2 /*return*/]; + }); + }); +} +function test2() { + return __awaiter(this, void 0, void 0, function () { + var i, limit; + return __generator(this, function (_a) { + i = 0; + limit = 10; + for (i = 1; i < limit; ++i) { + } + return [2 /*return*/]; + }); + }); +} +function test3() { + return __awaiter(this, void 0, void 0, function () { + var i; + return __generator(this, function (_a) { + i = 0; + for (;; ++i) { + } + return [2 /*return*/]; + }); + }); +} +function test4() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + for (;;) { + } + return [2 /*return*/]; + }); + }); +} diff --git a/tests/baselines/reference/asyncFunctionWithForStatementNoInitializer.symbols b/tests/baselines/reference/asyncFunctionWithForStatementNoInitializer.symbols new file mode 100644 index 0000000000000..b8b9e11b8bc8f --- /dev/null +++ b/tests/baselines/reference/asyncFunctionWithForStatementNoInitializer.symbols @@ -0,0 +1,51 @@ +=== tests/cases/compiler/asyncFunctionWithForStatementNoInitializer.ts === +async function test1() { +>test1 : Symbol(test1, Decl(asyncFunctionWithForStatementNoInitializer.ts, 0, 0)) + + let i = 0 +>i : Symbol(i, Decl(asyncFunctionWithForStatementNoInitializer.ts, 1, 7)) + + let limit = 10 +>limit : Symbol(limit, Decl(asyncFunctionWithForStatementNoInitializer.ts, 2, 7)) + + for (; i < limit; ++i) { +>i : Symbol(i, Decl(asyncFunctionWithForStatementNoInitializer.ts, 1, 7)) +>limit : Symbol(limit, Decl(asyncFunctionWithForStatementNoInitializer.ts, 2, 7)) +>i : Symbol(i, Decl(asyncFunctionWithForStatementNoInitializer.ts, 1, 7)) + } +} + +async function test2() { +>test2 : Symbol(test2, Decl(asyncFunctionWithForStatementNoInitializer.ts, 5, 1)) + + let i = 0 +>i : Symbol(i, Decl(asyncFunctionWithForStatementNoInitializer.ts, 8, 7)) + + let limit = 10 +>limit : Symbol(limit, Decl(asyncFunctionWithForStatementNoInitializer.ts, 9, 7)) + + for (i = 1; i < limit; ++i) { +>i : Symbol(i, Decl(asyncFunctionWithForStatementNoInitializer.ts, 8, 7)) +>i : Symbol(i, Decl(asyncFunctionWithForStatementNoInitializer.ts, 8, 7)) +>limit : Symbol(limit, Decl(asyncFunctionWithForStatementNoInitializer.ts, 9, 7)) +>i : Symbol(i, Decl(asyncFunctionWithForStatementNoInitializer.ts, 8, 7)) + } +} + +async function test3() { +>test3 : Symbol(test3, Decl(asyncFunctionWithForStatementNoInitializer.ts, 12, 1)) + + let i = 0 +>i : Symbol(i, Decl(asyncFunctionWithForStatementNoInitializer.ts, 15, 7)) + + for (;; ++i) { +>i : Symbol(i, Decl(asyncFunctionWithForStatementNoInitializer.ts, 15, 7)) + } +} + +async function test4() { +>test4 : Symbol(test4, Decl(asyncFunctionWithForStatementNoInitializer.ts, 18, 1)) + + for (;;) { + } +} diff --git a/tests/baselines/reference/asyncFunctionWithForStatementNoInitializer.types b/tests/baselines/reference/asyncFunctionWithForStatementNoInitializer.types new file mode 100644 index 0000000000000..d475f1d2fe885 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionWithForStatementNoInitializer.types @@ -0,0 +1,63 @@ +=== tests/cases/compiler/asyncFunctionWithForStatementNoInitializer.ts === +async function test1() { +>test1 : () => Promise + + let i = 0 +>i : number +>0 : 0 + + let limit = 10 +>limit : number +>10 : 10 + + for (; i < limit; ++i) { +>i < limit : boolean +>i : number +>limit : number +>++i : number +>i : number + } +} + +async function test2() { +>test2 : () => Promise + + let i = 0 +>i : number +>0 : 0 + + let limit = 10 +>limit : number +>10 : 10 + + for (i = 1; i < limit; ++i) { +>i = 1 : 1 +>i : number +>1 : 1 +>i < limit : boolean +>i : number +>limit : number +>++i : number +>i : number + } +} + +async function test3() { +>test3 : () => Promise + + let i = 0 +>i : number +>0 : 0 + + for (;; ++i) { +>++i : number +>i : number + } +} + +async function test4() { +>test4 : () => Promise + + for (;;) { + } +} diff --git a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.js b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.js index 50ecbbb2bebc5..2afcf5d7dfdc9 100644 --- a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.js +++ b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.js @@ -1,5 +1,4 @@ //// [asyncFunctionsAndStrictNullChecks.ts] - declare namespace Windows.Foundation { interface IPromise { then(success?: (value: TResult) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; diff --git a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols index 116406f765213..be15e4664634b 100644 --- a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols +++ b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols @@ -1,136 +1,135 @@ === tests/cases/compiler/asyncFunctionsAndStrictNullChecks.ts === - declare namespace Windows.Foundation { >Windows : Symbol(Windows, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 0)) ->Foundation : Symbol(Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 26)) +>Foundation : Symbol(Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 26)) interface IPromise { ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) then(success?: (value: TResult) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; ->then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 135)) +>then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135)) +>U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 13)) +>success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 16)) +>value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 27)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) +>U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 13)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 58)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 68)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) +>U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 13)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 95)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 108)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) +>U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 13)) + + then(success?: (value: TResult) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; +>then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 13)) >success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 16)) >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 13)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 58)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 68)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 13)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 95)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 108)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 85)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 98)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 13)) - then(success?: (value: TResult) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; ->then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 135)) + then(success?: (value: TResult) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; +>then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 13)) >success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 16)) >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 13)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 48)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 58)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 68)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 13)) >progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 85)) >progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 98)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 13)) - then(success?: (value: TResult) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; ->then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 135)) + then(success?: (value: TResult) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; +>then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 13)) >success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 16)) >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 13)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 48)) >error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 58)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 13)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 85)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 98)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 75)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 88)) +>IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 13)) - then(success?: (value: TResult) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; ->then : Symbol(IPromise.then, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 33), Decl(asyncFunctionsAndStrictNullChecks.ts, 3, 145), Decl(asyncFunctionsAndStrictNullChecks.ts, 4, 135), Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 135)) + done(success?: (value: TResult) => any, error?: (error: any) => any, progress?: (progress: any) => void): void; +>done : Symbol(IPromise.done, Decl(asyncFunctionsAndStrictNullChecks.ts, 5, 125)) >U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 13)) >success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 16)) >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) ->U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 13)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 48)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 58)) ->U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 13)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 75)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 88)) ->IPromise : Symbol(IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) ->U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 13)) - - done(success?: (value: TResult) => any, error?: (error: any) => any, progress?: (progress: any) => void): void; ->done : Symbol(IPromise.done, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 125)) ->U : Symbol(U, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 13)) ->success : Symbol(success, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 16)) ->value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 27)) ->TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 2, 23)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 50)) ->error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 60)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 79)) ->progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 92)) +>TResult : Symbol(TResult, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 23)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 50)) +>error : Symbol(error, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 60)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 79)) +>progress : Symbol(progress, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 92)) cancel(): void; ->cancel : Symbol(IPromise.cancel, Decl(asyncFunctionsAndStrictNullChecks.ts, 7, 122)) +>cancel : Symbol(IPromise.cancel, Decl(asyncFunctionsAndStrictNullChecks.ts, 6, 122)) } } async function sample(promise: Windows.Foundation.IPromise) { ->sample : Symbol(sample, Decl(asyncFunctionsAndStrictNullChecks.ts, 11, 1)) ->promise : Symbol(promise, Decl(asyncFunctionsAndStrictNullChecks.ts, 13, 22)) +>sample : Symbol(sample, Decl(asyncFunctionsAndStrictNullChecks.ts, 10, 1)) +>promise : Symbol(promise, Decl(asyncFunctionsAndStrictNullChecks.ts, 12, 22)) >Windows : Symbol(Windows, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 0)) ->Foundation : Symbol(Windows.Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 26)) ->IPromise : Symbol(Windows.Foundation.IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) +>Foundation : Symbol(Windows.Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 26)) +>IPromise : Symbol(Windows.Foundation.IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) var number = await promise; ->number : Symbol(number, Decl(asyncFunctionsAndStrictNullChecks.ts, 14, 7)) ->promise : Symbol(promise, Decl(asyncFunctionsAndStrictNullChecks.ts, 13, 22)) +>number : Symbol(number, Decl(asyncFunctionsAndStrictNullChecks.ts, 13, 7)) +>promise : Symbol(promise, Decl(asyncFunctionsAndStrictNullChecks.ts, 12, 22)) } declare function resolve1(value: T): Promise; ->resolve1 : Symbol(resolve1, Decl(asyncFunctionsAndStrictNullChecks.ts, 15, 1)) ->T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26)) ->value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 29)) ->T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26)) +>resolve1 : Symbol(resolve1, Decl(asyncFunctionsAndStrictNullChecks.ts, 14, 1)) +>T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26)) +>value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 29)) +>T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26)) +>T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26)) declare function resolve2(value: T): Windows.Foundation.IPromise; ->resolve2 : Symbol(resolve2, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 51)) ->T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 26)) ->value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 29)) ->T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 26)) +>resolve2 : Symbol(resolve2, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 51)) +>T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26)) +>value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 29)) +>T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26)) >Windows : Symbol(Windows, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 0)) ->Foundation : Symbol(Windows.Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 26)) ->IPromise : Symbol(Windows.Foundation.IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 1, 38)) ->T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 26)) +>Foundation : Symbol(Windows.Foundation, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 26)) +>IPromise : Symbol(Windows.Foundation.IPromise, Decl(asyncFunctionsAndStrictNullChecks.ts, 0, 38)) +>T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26)) async function sample2(x?: number) { ->sample2 : Symbol(sample2, Decl(asyncFunctionsAndStrictNullChecks.ts, 19, 71)) ->x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 21, 23)) +>sample2 : Symbol(sample2, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 71)) +>x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 20, 23)) let x1 = await resolve1(x); ->x1 : Symbol(x1, Decl(asyncFunctionsAndStrictNullChecks.ts, 22, 7)) ->resolve1 : Symbol(resolve1, Decl(asyncFunctionsAndStrictNullChecks.ts, 15, 1)) ->x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 21, 23)) +>x1 : Symbol(x1, Decl(asyncFunctionsAndStrictNullChecks.ts, 21, 7)) +>resolve1 : Symbol(resolve1, Decl(asyncFunctionsAndStrictNullChecks.ts, 14, 1)) +>x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 20, 23)) let x2 = await resolve2(x); ->x2 : Symbol(x2, Decl(asyncFunctionsAndStrictNullChecks.ts, 23, 7)) ->resolve2 : Symbol(resolve2, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 51)) ->x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 21, 23)) +>x2 : Symbol(x2, Decl(asyncFunctionsAndStrictNullChecks.ts, 22, 7)) +>resolve2 : Symbol(resolve2, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 51)) +>x : Symbol(x, Decl(asyncFunctionsAndStrictNullChecks.ts, 20, 23)) } diff --git a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types index f4eb4f7fa05da..bc48289821644 100644 --- a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types +++ b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types @@ -1,5 +1,4 @@ === tests/cases/compiler/asyncFunctionsAndStrictNullChecks.ts === - declare namespace Windows.Foundation { >Windows : any >Foundation : any diff --git a/tests/baselines/reference/asyncIIFE.js b/tests/baselines/reference/asyncIIFE.js index 2460dbdf26bb5..8ca877811136b 100644 --- a/tests/baselines/reference/asyncIIFE.js +++ b/tests/baselines/reference/asyncIIFE.js @@ -1,5 +1,4 @@ //// [asyncIIFE.ts] - function f1() { (async () => { await 10 diff --git a/tests/baselines/reference/asyncIIFE.symbols b/tests/baselines/reference/asyncIIFE.symbols index 92eb054bff04a..ab7f297379e64 100644 --- a/tests/baselines/reference/asyncIIFE.symbols +++ b/tests/baselines/reference/asyncIIFE.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/asyncIIFE.ts === - function f1() { >f1 : Symbol(f1, Decl(asyncIIFE.ts, 0, 0)) @@ -11,6 +10,6 @@ function f1() { })(); var x = 1; ->x : Symbol(x, Decl(asyncIIFE.ts, 7, 7)) +>x : Symbol(x, Decl(asyncIIFE.ts, 6, 7)) } diff --git a/tests/baselines/reference/asyncIIFE.types b/tests/baselines/reference/asyncIIFE.types index e49ab96681fed..886c8c3e5ecdd 100644 --- a/tests/baselines/reference/asyncIIFE.types +++ b/tests/baselines/reference/asyncIIFE.types @@ -1,5 +1,4 @@ === tests/cases/compiler/asyncIIFE.ts === - function f1() { >f1 : () => void diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.js b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.js index c97fda43011dd..a3c73c5c1b517 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.js +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.js @@ -1,5 +1,4 @@ //// [asyncUnParenthesizedArrowFunction_es2017.ts] - declare function someOtherFunction(i: any): Promise; const x = async i => await someOtherFunction(i) const x1 = async (i) => await someOtherFunction(i); diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols index d1de246fa93b0..45361cfb78e19 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es2017.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 35)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 35)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const x = async i => await someOtherFunction(i) ->x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 15)) +>x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 15)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 15)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 15)) const x1 = async (i) => await someOtherFunction(i); ->x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 3, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 3, 18)) +>x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 18)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 3, 18)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 18)) diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.types b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.types index ff573e29ed367..04c137f81b904 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.types +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es2017.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : (i: any) => Promise >i : any diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.js b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.js index 20b0421d01324..93062b6feee11 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.js +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.js @@ -1,5 +1,4 @@ //// [asyncUnParenthesizedArrowFunction_es5.ts] - declare function someOtherFunction(i: any): Promise; const x = async i => await someOtherFunction(i) const x1 = async (i) => await someOtherFunction(i); diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols index 82b73a199ea8e..c74ecdb8f7a8e 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es5.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 1, 35)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 0, 35)) >Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) const x = async i => await someOtherFunction(i) ->x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 15)) +>x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 1, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 1, 15)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 15)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 1, 15)) const x1 = async (i) => await someOtherFunction(i); ->x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 3, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 3, 18)) +>x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 18)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 3, 18)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 18)) diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.types b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.types index 745c56cf09b77..34ef19e6bd244 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.types +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es5/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es5.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : (i: any) => Promise >i : any diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.js b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.js index a4b097a871557..dd5f793ae9dd3 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.js +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.js @@ -1,5 +1,4 @@ //// [asyncUnParenthesizedArrowFunction_es6.ts] - declare function someOtherFunction(i: any): Promise; const x = async i => await someOtherFunction(i) const x1 = async (i) => await someOtherFunction(i); diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols index fee86b56cee12..26dc2840d2fca 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es6.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 35)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 35)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const x = async i => await someOtherFunction(i) ->x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 15)) +>x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 15)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 15)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 15)) const x1 = async (i) => await someOtherFunction(i); ->x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 3, 5)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 3, 18)) +>x1 : Symbol(x1, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 5)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 18)) >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 0)) ->i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 3, 18)) +>i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 18)) diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.types b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.types index d2cc97ce6c098..5a0f516c0ea2a 100644 --- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.types +++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es6.ts === - declare function someOtherFunction(i: any): Promise; >someOtherFunction : (i: any) => Promise >i : any diff --git a/tests/baselines/reference/augmentExportEquals1.errors.txt b/tests/baselines/reference/augmentExportEquals1.errors.txt index 2d15e6d622a41..fb2429d1c7f9e 100644 --- a/tests/baselines/reference/augmentExportEquals1.errors.txt +++ b/tests/baselines/reference/augmentExportEquals1.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/file2.ts(6,16): error TS2671: Cannot augment module './file1' because it resolves to a non-module entity. +tests/cases/compiler/file2.ts(5,16): error TS2671: Cannot augment module './file1' because it resolves to a non-module entity. tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. @@ -13,7 +13,6 @@ tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. export = x; ==== tests/cases/compiler/file2.ts (1 errors) ==== - import x = require("./file1"); // augmentation for './file1' diff --git a/tests/baselines/reference/augmentExportEquals1.js b/tests/baselines/reference/augmentExportEquals1.js index 7b0bfcf73353c..99a6e2e4bb00d 100644 --- a/tests/baselines/reference/augmentExportEquals1.js +++ b/tests/baselines/reference/augmentExportEquals1.js @@ -5,7 +5,6 @@ var x = 1; export = x; //// [file2.ts] - import x = require("./file1"); // augmentation for './file1' diff --git a/tests/baselines/reference/augmentExportEquals1_1.errors.txt b/tests/baselines/reference/augmentExportEquals1_1.errors.txt index aa89aa0c1d3e7..a3d0b28a26138 100644 --- a/tests/baselines/reference/augmentExportEquals1_1.errors.txt +++ b/tests/baselines/reference/augmentExportEquals1_1.errors.txt @@ -9,7 +9,6 @@ tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. ~ !!! error TS2503: Cannot find namespace 'x'. ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare module "file1" { var x: number; export = x; diff --git a/tests/baselines/reference/augmentExportEquals1_1.js b/tests/baselines/reference/augmentExportEquals1_1.js index 51bc67e7fa4d6..780043c81ca17 100644 --- a/tests/baselines/reference/augmentExportEquals1_1.js +++ b/tests/baselines/reference/augmentExportEquals1_1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals1_1.ts] //// //// [file1.d.ts] - declare module "file1" { var x: number; export = x; diff --git a/tests/baselines/reference/augmentExportEquals2.errors.txt b/tests/baselines/reference/augmentExportEquals2.errors.txt index b078a6623d7c0..8e1bf70fac413 100644 --- a/tests/baselines/reference/augmentExportEquals2.errors.txt +++ b/tests/baselines/reference/augmentExportEquals2.errors.txt @@ -9,7 +9,6 @@ tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. ~ !!! error TS2503: Cannot find namespace 'x'. ==== tests/cases/compiler/file1.ts (0 errors) ==== - function foo() {} export = foo; diff --git a/tests/baselines/reference/augmentExportEquals2.js b/tests/baselines/reference/augmentExportEquals2.js index efdce1bc0cf21..8ce1bb9010157 100644 --- a/tests/baselines/reference/augmentExportEquals2.js +++ b/tests/baselines/reference/augmentExportEquals2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals2.ts] //// //// [file1.ts] - function foo() {} export = foo; diff --git a/tests/baselines/reference/augmentExportEquals2_1.errors.txt b/tests/baselines/reference/augmentExportEquals2_1.errors.txt index 8e02f21176ae5..c1e1f2cba9b49 100644 --- a/tests/baselines/reference/augmentExportEquals2_1.errors.txt +++ b/tests/baselines/reference/augmentExportEquals2_1.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/file2.ts(6,16): error TS2671: Cannot augment module 'file1' because it resolves to a non-module entity. +tests/cases/compiler/file2.ts(5,16): error TS2671: Cannot augment module 'file1' because it resolves to a non-module entity. tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. @@ -9,14 +9,12 @@ tests/cases/compiler/file3.ts(3,8): error TS2503: Cannot find namespace 'x'. ~ !!! error TS2503: Cannot find namespace 'x'. ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare module "file1" { function foo(): void; export = foo; } ==== tests/cases/compiler/file2.ts (1 errors) ==== - /// import x = require("file1"); diff --git a/tests/baselines/reference/augmentExportEquals2_1.js b/tests/baselines/reference/augmentExportEquals2_1.js index 322ab3b36bf1a..93b76c0259c80 100644 --- a/tests/baselines/reference/augmentExportEquals2_1.js +++ b/tests/baselines/reference/augmentExportEquals2_1.js @@ -1,14 +1,12 @@ //// [tests/cases/compiler/augmentExportEquals2_1.ts] //// //// [file1.d.ts] - declare module "file1" { function foo(): void; export = foo; } //// [file2.ts] - /// import x = require("file1"); diff --git a/tests/baselines/reference/augmentExportEquals3.js b/tests/baselines/reference/augmentExportEquals3.js index 387ef86ff7921..3ff5f574488e4 100644 --- a/tests/baselines/reference/augmentExportEquals3.js +++ b/tests/baselines/reference/augmentExportEquals3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals3.ts] //// //// [file1.ts] - function foo() {} namespace foo { export var v = 1; diff --git a/tests/baselines/reference/augmentExportEquals3.symbols b/tests/baselines/reference/augmentExportEquals3.symbols index 485f977321f6f..06ac04b39f39c 100644 --- a/tests/baselines/reference/augmentExportEquals3.symbols +++ b/tests/baselines/reference/augmentExportEquals3.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/file1.ts === - function foo() {} ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 17), Decl(file2.ts, 1, 8)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 17), Decl(file2.ts, 1, 8)) namespace foo { ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 17), Decl(file2.ts, 1, 8)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 17), Decl(file2.ts, 1, 8)) export var v = 1; ->v : Symbol(v, Decl(file1.ts, 3, 14)) +>v : Symbol(v, Decl(file1.ts, 2, 14)) } export = foo; ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 17)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 17)) === tests/cases/compiler/file2.ts === import x = require("./file1"); diff --git a/tests/baselines/reference/augmentExportEquals3.types b/tests/baselines/reference/augmentExportEquals3.types index f900d59735ea4..37362bc9649fa 100644 --- a/tests/baselines/reference/augmentExportEquals3.types +++ b/tests/baselines/reference/augmentExportEquals3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - function foo() {} >foo : typeof foo diff --git a/tests/baselines/reference/augmentExportEquals4.js b/tests/baselines/reference/augmentExportEquals4.js index 37be30731de08..3ca522bbc0865 100644 --- a/tests/baselines/reference/augmentExportEquals4.js +++ b/tests/baselines/reference/augmentExportEquals4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals4.ts] //// //// [file1.ts] - class foo {} namespace foo { export var v = 1; diff --git a/tests/baselines/reference/augmentExportEquals4.symbols b/tests/baselines/reference/augmentExportEquals4.symbols index 7394e8c6b2828..2a4e3dbc1471b 100644 --- a/tests/baselines/reference/augmentExportEquals4.symbols +++ b/tests/baselines/reference/augmentExportEquals4.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/file1.ts === - class foo {} ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12), Decl(file2.ts, 1, 8)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12), Decl(file2.ts, 1, 8)) namespace foo { ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12), Decl(file2.ts, 1, 8)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12), Decl(file2.ts, 1, 8)) export var v = 1; ->v : Symbol(v, Decl(file1.ts, 3, 14)) +>v : Symbol(v, Decl(file1.ts, 2, 14)) } export = foo; ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12)) === tests/cases/compiler/file2.ts === import x = require("./file1"); diff --git a/tests/baselines/reference/augmentExportEquals4.types b/tests/baselines/reference/augmentExportEquals4.types index c7ffe8bd774fa..295156ffb590f 100644 --- a/tests/baselines/reference/augmentExportEquals4.types +++ b/tests/baselines/reference/augmentExportEquals4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - class foo {} >foo : foo diff --git a/tests/baselines/reference/augmentExportEquals4_1.js b/tests/baselines/reference/augmentExportEquals4_1.js index 71d39aedb1ff0..cd2f54599699e 100644 --- a/tests/baselines/reference/augmentExportEquals4_1.js +++ b/tests/baselines/reference/augmentExportEquals4_1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals4_1.ts] //// //// [file1.d.ts] - declare module "file1" { class foo {} namespace foo { diff --git a/tests/baselines/reference/augmentExportEquals4_1.symbols b/tests/baselines/reference/augmentExportEquals4_1.symbols index 9954f71bfbc70..1488645898c99 100644 --- a/tests/baselines/reference/augmentExportEquals4_1.symbols +++ b/tests/baselines/reference/augmentExportEquals4_1.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/file1.d.ts === - declare module "file1" { class foo {} ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16), Decl(file2.ts, 2, 8)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16), Decl(file2.ts, 2, 8)) namespace foo { ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16), Decl(file2.ts, 2, 8)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16), Decl(file2.ts, 2, 8)) export var v: number; ->v : Symbol(v, Decl(file1.d.ts, 4, 18)) +>v : Symbol(v, Decl(file1.d.ts, 3, 18)) } export = foo; ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16)) } diff --git a/tests/baselines/reference/augmentExportEquals4_1.types b/tests/baselines/reference/augmentExportEquals4_1.types index 60a7c2d77bba0..8eaf1c6cbbaaf 100644 --- a/tests/baselines/reference/augmentExportEquals4_1.types +++ b/tests/baselines/reference/augmentExportEquals4_1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.d.ts === - declare module "file1" { class foo {} >foo : foo diff --git a/tests/baselines/reference/augmentExportEquals5.js b/tests/baselines/reference/augmentExportEquals5.js index 7bc5102ca9d4c..e028b2331daf5 100644 --- a/tests/baselines/reference/augmentExportEquals5.js +++ b/tests/baselines/reference/augmentExportEquals5.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals5.ts] //// //// [express.d.ts] - - declare module Express { export interface Request { } export interface Response { } diff --git a/tests/baselines/reference/augmentExportEquals5.symbols b/tests/baselines/reference/augmentExportEquals5.symbols index 09da5f32d72be..d55e8eed0218d 100644 --- a/tests/baselines/reference/augmentExportEquals5.symbols +++ b/tests/baselines/reference/augmentExportEquals5.symbols @@ -1,166 +1,164 @@ === tests/cases/compiler/express.d.ts === - - declare module Express { >Express : Symbol(Express, Decl(express.d.ts, 0, 0)) export interface Request { } ->Request : Symbol(Request, Decl(express.d.ts, 2, 24)) +>Request : Symbol(Request, Decl(express.d.ts, 0, 24)) export interface Response { } ->Response : Symbol(Response, Decl(express.d.ts, 3, 32)) +>Response : Symbol(Response, Decl(express.d.ts, 1, 32)) export interface Application { } ->Application : Symbol(Application, Decl(express.d.ts, 4, 33)) +>Application : Symbol(Application, Decl(express.d.ts, 2, 33)) } declare module "express" { function e(): e.Express; ->e : Symbol(e, Decl(express.d.ts, 8, 26), Decl(express.d.ts, 9, 28), Decl(augmentation.ts, 1, 29)) ->e : Symbol(e, Decl(express.d.ts, 8, 26), Decl(express.d.ts, 9, 28)) ->Express : Symbol(Express, Decl(express.d.ts, 54, 9)) +>e : Symbol(e, Decl(express.d.ts, 6, 26), Decl(express.d.ts, 7, 28), Decl(augmentation.ts, 1, 29)) +>e : Symbol(e, Decl(express.d.ts, 6, 26), Decl(express.d.ts, 7, 28)) +>Express : Symbol(Express, Decl(express.d.ts, 52, 9)) namespace e { ->e : Symbol(e, Decl(express.d.ts, 8, 26), Decl(express.d.ts, 9, 28), Decl(augmentation.ts, 1, 29)) +>e : Symbol(e, Decl(express.d.ts, 6, 26), Decl(express.d.ts, 7, 28), Decl(augmentation.ts, 1, 29)) interface IRoute { ->IRoute : Symbol(IRoute, Decl(express.d.ts, 10, 17)) +>IRoute : Symbol(IRoute, Decl(express.d.ts, 8, 17)) all(...handler: RequestHandler[]): IRoute; ->all : Symbol(IRoute.all, Decl(express.d.ts, 11, 26)) ->handler : Symbol(handler, Decl(express.d.ts, 12, 16)) ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) ->IRoute : Symbol(IRoute, Decl(express.d.ts, 10, 17)) +>all : Symbol(IRoute.all, Decl(express.d.ts, 9, 26)) +>handler : Symbol(handler, Decl(express.d.ts, 10, 16)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) +>IRoute : Symbol(IRoute, Decl(express.d.ts, 8, 17)) } interface IRouterMatcher { ->IRouterMatcher : Symbol(IRouterMatcher, Decl(express.d.ts, 13, 9)) ->T : Symbol(T, Decl(express.d.ts, 15, 33)) +>IRouterMatcher : Symbol(IRouterMatcher, Decl(express.d.ts, 11, 9)) +>T : Symbol(T, Decl(express.d.ts, 13, 33)) (name: string|RegExp, ...handlers: RequestHandler[]): T; ->name : Symbol(name, Decl(express.d.ts, 16, 13)) +>name : Symbol(name, Decl(express.d.ts, 14, 13)) >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->handlers : Symbol(handlers, Decl(express.d.ts, 16, 33)) ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) ->T : Symbol(T, Decl(express.d.ts, 15, 33)) +>handlers : Symbol(handlers, Decl(express.d.ts, 14, 33)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) +>T : Symbol(T, Decl(express.d.ts, 13, 33)) } interface IRouter extends RequestHandler { ->IRouter : Symbol(IRouter, Decl(express.d.ts, 17, 9)) ->T : Symbol(T, Decl(express.d.ts, 19, 26)) ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) +>IRouter : Symbol(IRouter, Decl(express.d.ts, 15, 9)) +>T : Symbol(T, Decl(express.d.ts, 17, 26)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) route(path: string): IRoute; ->route : Symbol(IRouter.route, Decl(express.d.ts, 19, 53)) ->path : Symbol(path, Decl(express.d.ts, 20, 18)) ->IRoute : Symbol(IRoute, Decl(express.d.ts, 10, 17)) +>route : Symbol(IRouter.route, Decl(express.d.ts, 17, 53)) +>path : Symbol(path, Decl(express.d.ts, 18, 18)) +>IRoute : Symbol(IRoute, Decl(express.d.ts, 8, 17)) } export function Router(options?: any): Router; ->Router : Symbol(Router, Decl(express.d.ts, 21, 9), Decl(express.d.ts, 23, 54)) ->options : Symbol(options, Decl(express.d.ts, 23, 31)) ->Router : Symbol(Router, Decl(express.d.ts, 21, 9), Decl(express.d.ts, 23, 54)) +>Router : Symbol(Router, Decl(express.d.ts, 19, 9), Decl(express.d.ts, 21, 54)) +>options : Symbol(options, Decl(express.d.ts, 21, 31)) +>Router : Symbol(Router, Decl(express.d.ts, 19, 9), Decl(express.d.ts, 21, 54)) export interface Router extends IRouter {} ->Router : Symbol(Router, Decl(express.d.ts, 21, 9), Decl(express.d.ts, 23, 54)) ->IRouter : Symbol(IRouter, Decl(express.d.ts, 17, 9)) ->Router : Symbol(Router, Decl(express.d.ts, 21, 9), Decl(express.d.ts, 23, 54)) +>Router : Symbol(Router, Decl(express.d.ts, 19, 9), Decl(express.d.ts, 21, 54)) +>IRouter : Symbol(IRouter, Decl(express.d.ts, 15, 9)) +>Router : Symbol(Router, Decl(express.d.ts, 19, 9), Decl(express.d.ts, 21, 54)) interface Errback { (err: Error): void; } ->Errback : Symbol(Errback, Decl(express.d.ts, 25, 58)) ->err : Symbol(err, Decl(express.d.ts, 27, 29)) +>Errback : Symbol(Errback, Decl(express.d.ts, 23, 58)) +>err : Symbol(err, Decl(express.d.ts, 25, 29)) >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) interface Request extends Express.Request { ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) ->Express.Request : Symbol(Express.Request, Decl(express.d.ts, 2, 24)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) +>Express.Request : Symbol(Express.Request, Decl(express.d.ts, 0, 24)) >Express : Symbol(Express, Decl(express.d.ts, 0, 0)) ->Request : Symbol(Express.Request, Decl(express.d.ts, 2, 24)) +>Request : Symbol(Express.Request, Decl(express.d.ts, 0, 24)) get (name: string): string; ->get : Symbol(Request.get, Decl(express.d.ts, 29, 51)) ->name : Symbol(name, Decl(express.d.ts, 31, 17)) +>get : Symbol(Request.get, Decl(express.d.ts, 27, 51)) +>name : Symbol(name, Decl(express.d.ts, 29, 17)) } interface Response extends Express.Response { ->Response : Symbol(Response, Decl(express.d.ts, 32, 9)) ->Express.Response : Symbol(Express.Response, Decl(express.d.ts, 3, 32)) +>Response : Symbol(Response, Decl(express.d.ts, 30, 9)) +>Express.Response : Symbol(Express.Response, Decl(express.d.ts, 1, 32)) >Express : Symbol(Express, Decl(express.d.ts, 0, 0)) ->Response : Symbol(Express.Response, Decl(express.d.ts, 3, 32)) +>Response : Symbol(Express.Response, Decl(express.d.ts, 1, 32)) charset: string; ->charset : Symbol(Response.charset, Decl(express.d.ts, 34, 53)) +>charset : Symbol(Response.charset, Decl(express.d.ts, 32, 53)) } interface ErrorRequestHandler { ->ErrorRequestHandler : Symbol(ErrorRequestHandler, Decl(express.d.ts, 36, 9)) +>ErrorRequestHandler : Symbol(ErrorRequestHandler, Decl(express.d.ts, 34, 9)) (err: any, req: Request, res: Response, next: Function): any; ->err : Symbol(err, Decl(express.d.ts, 39, 13)) ->req : Symbol(req, Decl(express.d.ts, 39, 22)) ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) ->res : Symbol(res, Decl(express.d.ts, 39, 36)) ->Response : Symbol(Response, Decl(express.d.ts, 32, 9)) ->next : Symbol(next, Decl(express.d.ts, 39, 51)) +>err : Symbol(err, Decl(express.d.ts, 37, 13)) +>req : Symbol(req, Decl(express.d.ts, 37, 22)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) +>res : Symbol(res, Decl(express.d.ts, 37, 36)) +>Response : Symbol(Response, Decl(express.d.ts, 30, 9)) +>next : Symbol(next, Decl(express.d.ts, 37, 51)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface RequestHandler { ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) (req: Request, res: Response, next: Function): any; ->req : Symbol(req, Decl(express.d.ts, 43, 13)) ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) ->res : Symbol(res, Decl(express.d.ts, 43, 26)) ->Response : Symbol(Response, Decl(express.d.ts, 32, 9)) ->next : Symbol(next, Decl(express.d.ts, 43, 41)) +>req : Symbol(req, Decl(express.d.ts, 41, 13)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) +>res : Symbol(res, Decl(express.d.ts, 41, 26)) +>Response : Symbol(Response, Decl(express.d.ts, 30, 9)) +>next : Symbol(next, Decl(express.d.ts, 41, 41)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface Handler extends RequestHandler {} ->Handler : Symbol(Handler, Decl(express.d.ts, 44, 9)) ->RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 40, 9)) +>Handler : Symbol(Handler, Decl(express.d.ts, 42, 9)) +>RequestHandler : Symbol(RequestHandler, Decl(express.d.ts, 38, 9)) interface RequestParamHandler { ->RequestParamHandler : Symbol(RequestParamHandler, Decl(express.d.ts, 46, 51)) +>RequestParamHandler : Symbol(RequestParamHandler, Decl(express.d.ts, 44, 51)) (req: Request, res: Response, next: Function, param: any): any; ->req : Symbol(req, Decl(express.d.ts, 49, 13)) ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) ->res : Symbol(res, Decl(express.d.ts, 49, 26)) ->Response : Symbol(Response, Decl(express.d.ts, 32, 9)) ->next : Symbol(next, Decl(express.d.ts, 49, 41)) +>req : Symbol(req, Decl(express.d.ts, 47, 13)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) +>res : Symbol(res, Decl(express.d.ts, 47, 26)) +>Response : Symbol(Response, Decl(express.d.ts, 30, 9)) +>next : Symbol(next, Decl(express.d.ts, 47, 41)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->param : Symbol(param, Decl(express.d.ts, 49, 57)) +>param : Symbol(param, Decl(express.d.ts, 47, 57)) } interface Application extends IRouter, Express.Application { ->Application : Symbol(Application, Decl(express.d.ts, 50, 9)) ->IRouter : Symbol(IRouter, Decl(express.d.ts, 17, 9)) ->Application : Symbol(Application, Decl(express.d.ts, 50, 9)) ->Express.Application : Symbol(Express.Application, Decl(express.d.ts, 4, 33)) +>Application : Symbol(Application, Decl(express.d.ts, 48, 9)) +>IRouter : Symbol(IRouter, Decl(express.d.ts, 15, 9)) +>Application : Symbol(Application, Decl(express.d.ts, 48, 9)) +>Express.Application : Symbol(Express.Application, Decl(express.d.ts, 2, 33)) >Express : Symbol(Express, Decl(express.d.ts, 0, 0)) ->Application : Symbol(Express.Application, Decl(express.d.ts, 4, 33)) +>Application : Symbol(Express.Application, Decl(express.d.ts, 2, 33)) routes: any; ->routes : Symbol(Application.routes, Decl(express.d.ts, 52, 81)) +>routes : Symbol(Application.routes, Decl(express.d.ts, 50, 81)) } interface Express extends Application { ->Express : Symbol(Express, Decl(express.d.ts, 54, 9)) ->Application : Symbol(Application, Decl(express.d.ts, 50, 9)) +>Express : Symbol(Express, Decl(express.d.ts, 52, 9)) +>Application : Symbol(Application, Decl(express.d.ts, 48, 9)) createApplication(): Application; ->createApplication : Symbol(Express.createApplication, Decl(express.d.ts, 56, 47)) ->Application : Symbol(Application, Decl(express.d.ts, 50, 9)) +>createApplication : Symbol(Express.createApplication, Decl(express.d.ts, 54, 47)) +>Application : Symbol(Application, Decl(express.d.ts, 48, 9)) } var static: any; ->static : Symbol(static, Decl(express.d.ts, 60, 11)) +>static : Symbol(static, Decl(express.d.ts, 58, 11)) } export = e; ->e : Symbol(e, Decl(express.d.ts, 8, 26), Decl(express.d.ts, 9, 28)) +>e : Symbol(e, Decl(express.d.ts, 6, 26), Decl(express.d.ts, 7, 28)) } === tests/cases/compiler/augmentation.ts === @@ -170,7 +168,7 @@ import * as e from "express"; declare module "express" { interface Request { ->Request : Symbol(Request, Decl(express.d.ts, 27, 49), Decl(augmentation.ts, 2, 26)) +>Request : Symbol(Request, Decl(express.d.ts, 25, 49), Decl(augmentation.ts, 2, 26)) id: number; >id : Symbol(Request.id, Decl(augmentation.ts, 3, 23)) diff --git a/tests/baselines/reference/augmentExportEquals5.types b/tests/baselines/reference/augmentExportEquals5.types index 7d4d765e5ee32..c0444d35358fc 100644 --- a/tests/baselines/reference/augmentExportEquals5.types +++ b/tests/baselines/reference/augmentExportEquals5.types @@ -1,6 +1,4 @@ === tests/cases/compiler/express.d.ts === - - declare module Express { >Express : any diff --git a/tests/baselines/reference/augmentExportEquals6.js b/tests/baselines/reference/augmentExportEquals6.js index 4299f8653dd84..1f6904a4664c6 100644 --- a/tests/baselines/reference/augmentExportEquals6.js +++ b/tests/baselines/reference/augmentExportEquals6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals6.ts] //// //// [file1.ts] - class foo {} namespace foo { export class A {} diff --git a/tests/baselines/reference/augmentExportEquals6.symbols b/tests/baselines/reference/augmentExportEquals6.symbols index 9ccf8685af776..33ec14ed3346c 100644 --- a/tests/baselines/reference/augmentExportEquals6.symbols +++ b/tests/baselines/reference/augmentExportEquals6.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/file1.ts === - class foo {} ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12), Decl(file2.ts, 1, 10)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12), Decl(file2.ts, 1, 10)) namespace foo { ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12), Decl(file2.ts, 1, 10)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12), Decl(file2.ts, 1, 10)) export class A {} ->A : Symbol(A, Decl(file1.ts, 2, 15), Decl(file2.ts, 4, 26)) +>A : Symbol(A, Decl(file1.ts, 1, 15), Decl(file2.ts, 4, 26)) export namespace B { export let a; } ->B : Symbol(B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) ->a : Symbol(a, Decl(file1.ts, 4, 35)) +>B : Symbol(B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) +>a : Symbol(a, Decl(file1.ts, 3, 35)) } export = foo; ->foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 1, 12)) +>foo : Symbol(foo, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 12)) === tests/cases/compiler/file2.ts === import x = require("./file1"); @@ -22,19 +21,19 @@ import x = require("./file1"); x.B.b = 1; >x.B.b : Symbol(x.B.b, Decl(file2.ts, 7, 18)) ->x.B : Symbol(x.B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>x.B : Symbol(x.B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) >x : Symbol(x, Decl(file2.ts, 0, 0)) ->B : Symbol(x.B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>B : Symbol(x.B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) >b : Symbol(x.B.b, Decl(file2.ts, 7, 18)) // OK - './file1' is a namespace declare module "./file1" { interface A { a: number } ->A : Symbol(A, Decl(file1.ts, 2, 15), Decl(file2.ts, 4, 26)) +>A : Symbol(A, Decl(file1.ts, 1, 15), Decl(file2.ts, 4, 26)) >a : Symbol(A.a, Decl(file2.ts, 5, 17)) namespace B { ->B : Symbol(B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>B : Symbol(B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) export let b: number; >b : Symbol(b, Decl(file2.ts, 7, 18)) @@ -49,7 +48,7 @@ import "./file2"; let a: x.A; >a : Symbol(a, Decl(file3.ts, 2, 3)) >x : Symbol(x, Decl(file3.ts, 0, 6)) ->A : Symbol(x.A, Decl(file1.ts, 2, 15), Decl(file2.ts, 4, 26)) +>A : Symbol(x.A, Decl(file1.ts, 1, 15), Decl(file2.ts, 4, 26)) let b = a.a; >b : Symbol(b, Decl(file3.ts, 3, 3)) @@ -60,8 +59,8 @@ let b = a.a; let c = x.B.b; >c : Symbol(c, Decl(file3.ts, 4, 3)) >x.B.b : Symbol(x.B.b, Decl(file2.ts, 7, 18)) ->x.B : Symbol(x.B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>x.B : Symbol(x.B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) >x : Symbol(x, Decl(file3.ts, 0, 6)) ->B : Symbol(x.B, Decl(file1.ts, 3, 21), Decl(file2.ts, 5, 29)) +>B : Symbol(x.B, Decl(file1.ts, 2, 21), Decl(file2.ts, 5, 29)) >b : Symbol(x.B.b, Decl(file2.ts, 7, 18)) diff --git a/tests/baselines/reference/augmentExportEquals6.types b/tests/baselines/reference/augmentExportEquals6.types index e2342e96dfb4f..01b7095b1693a 100644 --- a/tests/baselines/reference/augmentExportEquals6.types +++ b/tests/baselines/reference/augmentExportEquals6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - class foo {} >foo : foo diff --git a/tests/baselines/reference/augmentExportEquals6_1.js b/tests/baselines/reference/augmentExportEquals6_1.js index e69728a766bd6..d1c7170993b9e 100644 --- a/tests/baselines/reference/augmentExportEquals6_1.js +++ b/tests/baselines/reference/augmentExportEquals6_1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/augmentExportEquals6_1.ts] //// //// [file1.d.ts] - declare module "file1" { class foo {} namespace foo { diff --git a/tests/baselines/reference/augmentExportEquals6_1.symbols b/tests/baselines/reference/augmentExportEquals6_1.symbols index c66f01e2d14f3..60f8b84565777 100644 --- a/tests/baselines/reference/augmentExportEquals6_1.symbols +++ b/tests/baselines/reference/augmentExportEquals6_1.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/file1.d.ts === - declare module "file1" { class foo {} ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16), Decl(file2.ts, 1, 28)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16), Decl(file2.ts, 1, 28)) namespace foo { ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16), Decl(file2.ts, 1, 28)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16), Decl(file2.ts, 1, 28)) class A {} ->A : Symbol(A, Decl(file1.d.ts, 3, 19), Decl(file2.ts, 4, 24)) +>A : Symbol(A, Decl(file1.d.ts, 2, 19), Decl(file2.ts, 4, 24)) } export = foo; ->foo : Symbol(foo, Decl(file1.d.ts, 1, 24), Decl(file1.d.ts, 2, 16)) +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24), Decl(file1.d.ts, 1, 16)) } @@ -23,7 +22,7 @@ import x = require("file1"); // OK - './file1' is a namespace declare module "file1" { interface A { a: number } ->A : Symbol(A, Decl(file1.d.ts, 3, 19), Decl(file2.ts, 4, 24)) +>A : Symbol(A, Decl(file1.d.ts, 2, 19), Decl(file2.ts, 4, 24)) >a : Symbol(A.a, Decl(file2.ts, 5, 17)) } @@ -35,7 +34,7 @@ import "file2"; let a: x.A; >a : Symbol(a, Decl(file3.ts, 2, 3)) >x : Symbol(x, Decl(file3.ts, 0, 6)) ->A : Symbol(x.A, Decl(file1.d.ts, 3, 19), Decl(file2.ts, 4, 24)) +>A : Symbol(x.A, Decl(file1.d.ts, 2, 19), Decl(file2.ts, 4, 24)) let b = a.a; >b : Symbol(b, Decl(file3.ts, 3, 3)) diff --git a/tests/baselines/reference/augmentExportEquals6_1.types b/tests/baselines/reference/augmentExportEquals6_1.types index 9d6042ee65969..a6041ecda8103 100644 --- a/tests/baselines/reference/augmentExportEquals6_1.types +++ b/tests/baselines/reference/augmentExportEquals6_1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.d.ts === - declare module "file1" { class foo {} >foo : foo diff --git a/tests/baselines/reference/await_unaryExpression_es2017.js b/tests/baselines/reference/await_unaryExpression_es2017.js index 83fce6588e646..f05bda125fc11 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017.js +++ b/tests/baselines/reference/await_unaryExpression_es2017.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es2017.ts] - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es2017.symbols b/tests/baselines/reference/await_unaryExpression_es2017.symbols index 1aa31031177c0..51955ac03b7e2 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017.symbols +++ b/tests/baselines/reference/await_unaryExpression_es2017.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/await_unaryExpression_es2017.ts === - async function bar() { >bar : Symbol(bar, Decl(await_unaryExpression_es2017.ts, 0, 0)) @@ -7,19 +6,19 @@ async function bar() { } async function bar1() { ->bar1 : Symbol(bar1, Decl(await_unaryExpression_es2017.ts, 3, 1)) +>bar1 : Symbol(bar1, Decl(await_unaryExpression_es2017.ts, 2, 1)) +await 42; // OK } async function bar3() { ->bar3 : Symbol(bar3, Decl(await_unaryExpression_es2017.ts, 7, 1)) +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es2017.ts, 6, 1)) -await 42; // OK } async function bar4() { ->bar4 : Symbol(bar4, Decl(await_unaryExpression_es2017.ts, 11, 1)) +>bar4 : Symbol(bar4, Decl(await_unaryExpression_es2017.ts, 10, 1)) ~await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es2017.types b/tests/baselines/reference/await_unaryExpression_es2017.types index 4f4254df318a9..5402038cc7bf3 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017.types +++ b/tests/baselines/reference/await_unaryExpression_es2017.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/await_unaryExpression_es2017.ts === - async function bar() { >bar : () => Promise diff --git a/tests/baselines/reference/await_unaryExpression_es2017_1.errors.txt b/tests/baselines/reference/await_unaryExpression_es2017_1.errors.txt index afc9ac40f1e5a..06970ab285678 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_1.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es2017_1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts(7,12): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts(11,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts(6,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts(10,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts (2 errors) ==== - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es2017_1.js b/tests/baselines/reference/await_unaryExpression_es2017_1.js index f863fb19a7e1f..49a3b34b172e4 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_1.js +++ b/tests/baselines/reference/await_unaryExpression_es2017_1.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es2017_1.ts] - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es2017_2.errors.txt b/tests/baselines/reference/await_unaryExpression_es2017_2.errors.txt index e9966847189d2..e561ceaf79b99 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_2.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es2017_2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts(3,12): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts(7,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts(2,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts(6,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts (2 errors) ==== - async function bar1() { delete await 42; ~~~~~~~~ diff --git a/tests/baselines/reference/await_unaryExpression_es2017_2.js b/tests/baselines/reference/await_unaryExpression_es2017_2.js index b982b20245c0e..8978e460e7df9 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_2.js +++ b/tests/baselines/reference/await_unaryExpression_es2017_2.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es2017_2.ts] - async function bar1() { delete await 42; } diff --git a/tests/baselines/reference/await_unaryExpression_es2017_3.errors.txt b/tests/baselines/reference/await_unaryExpression_es2017_3.errors.txt index 5d11c4bbb20eb..da533765a0788 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_3.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es2017_3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts(3,7): error TS1109: Expression expected. -tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts(7,7): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts(2,7): error TS1109: Expression expected. +tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts(6,7): error TS1109: Expression expected. ==== tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts (2 errors) ==== - async function bar1() { ++await 42; // Error ~~~~~ diff --git a/tests/baselines/reference/await_unaryExpression_es2017_3.js b/tests/baselines/reference/await_unaryExpression_es2017_3.js index 5e3c3c3a4bf44..b2a1593a9d0bd 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_3.js +++ b/tests/baselines/reference/await_unaryExpression_es2017_3.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es2017_3.ts] - async function bar1() { ++await 42; // Error } diff --git a/tests/baselines/reference/await_unaryExpression_es6.js b/tests/baselines/reference/await_unaryExpression_es6.js index f9183f7af3e31..1361f80bc8ed1 100644 --- a/tests/baselines/reference/await_unaryExpression_es6.js +++ b/tests/baselines/reference/await_unaryExpression_es6.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es6.ts] - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es6.symbols b/tests/baselines/reference/await_unaryExpression_es6.symbols index 81edd4b981b1b..57dfbbc67e37c 100644 --- a/tests/baselines/reference/await_unaryExpression_es6.symbols +++ b/tests/baselines/reference/await_unaryExpression_es6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/await_unaryExpression_es6.ts === - async function bar() { >bar : Symbol(bar, Decl(await_unaryExpression_es6.ts, 0, 0)) @@ -7,19 +6,19 @@ async function bar() { } async function bar1() { ->bar1 : Symbol(bar1, Decl(await_unaryExpression_es6.ts, 3, 1)) +>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6.ts, 2, 1)) +await 42; // OK } async function bar3() { ->bar3 : Symbol(bar3, Decl(await_unaryExpression_es6.ts, 7, 1)) +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6.ts, 6, 1)) -await 42; // OK } async function bar4() { ->bar4 : Symbol(bar4, Decl(await_unaryExpression_es6.ts, 11, 1)) +>bar4 : Symbol(bar4, Decl(await_unaryExpression_es6.ts, 10, 1)) ~await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es6.types b/tests/baselines/reference/await_unaryExpression_es6.types index 14b4fbf89ac27..15d9193660334 100644 --- a/tests/baselines/reference/await_unaryExpression_es6.types +++ b/tests/baselines/reference/await_unaryExpression_es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/await_unaryExpression_es6.ts === - async function bar() { >bar : () => Promise diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.errors.txt b/tests/baselines/reference/await_unaryExpression_es6_1.errors.txt index b4f866ff0ecd8..9e9d05bf2ab6a 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_1.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es6_1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts(7,12): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts(11,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts(6,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts(10,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts (2 errors) ==== - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.js b/tests/baselines/reference/await_unaryExpression_es6_1.js index 948e537cb01d3..297299e44621c 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_1.js +++ b/tests/baselines/reference/await_unaryExpression_es6_1.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es6_1.ts] - async function bar() { !await 42; // OK } diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.errors.txt b/tests/baselines/reference/await_unaryExpression_es6_2.errors.txt index 989e96c7d3f63..1c440e84af79c 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_2.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es6_2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts(3,12): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts(7,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts(2,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts(6,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts (2 errors) ==== - async function bar1() { delete await 42; ~~~~~~~~ diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.js b/tests/baselines/reference/await_unaryExpression_es6_2.js index 4b4c1cd65130b..fdf83e3def1ad 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_2.js +++ b/tests/baselines/reference/await_unaryExpression_es6_2.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es6_2.ts] - async function bar1() { delete await 42; } diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt b/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt index 5518f84983f78..373e6739461b4 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt +++ b/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(3,7): error TS1109: Expression expected. -tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(7,7): error TS1109: Expression expected. +tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(2,7): error TS1109: Expression expected. +tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(6,7): error TS1109: Expression expected. ==== tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts (2 errors) ==== - async function bar1() { ++await 42; // Error ~~~~~ diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.js b/tests/baselines/reference/await_unaryExpression_es6_3.js index 6db5d5a7c31cb..23985832ce1f7 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_3.js +++ b/tests/baselines/reference/await_unaryExpression_es6_3.js @@ -1,5 +1,4 @@ //// [await_unaryExpression_es6_3.ts] - async function bar1() { ++await 42; // Error } diff --git a/tests/baselines/reference/bangInModuleName.js b/tests/baselines/reference/bangInModuleName.js index f58827e1ae5f1..1a6961f59da5c 100644 --- a/tests/baselines/reference/bangInModuleName.js +++ b/tests/baselines/reference/bangInModuleName.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/bangInModuleName.ts] //// //// [a.d.ts] - - declare module "http" { } @@ -12,7 +10,6 @@ declare module 'intern/dojo/node!http' { } //// [a.ts] - /// import * as http from 'intern/dojo/node!http'; diff --git a/tests/baselines/reference/bangInModuleName.symbols b/tests/baselines/reference/bangInModuleName.symbols index 63ba5d106d800..08bcf487cc8cb 100644 --- a/tests/baselines/reference/bangInModuleName.symbols +++ b/tests/baselines/reference/bangInModuleName.symbols @@ -1,21 +1,18 @@ === tests/cases/compiler/a.ts === - /// import * as http from 'intern/dojo/node!http'; ->http : Symbol(http, Decl(a.ts, 3, 6)) +>http : Symbol(http, Decl(a.ts, 2, 6)) === tests/cases/compiler/a.d.ts === - - declare module "http" { } declare module 'intern/dojo/node!http' { import http = require('http'); ->http : Symbol(http, Decl(a.d.ts, 5, 40)) +>http : Symbol(http, Decl(a.d.ts, 3, 40)) export = http; ->http : Symbol(http, Decl(a.d.ts, 5, 40)) +>http : Symbol(http, Decl(a.d.ts, 3, 40)) } diff --git a/tests/baselines/reference/bangInModuleName.types b/tests/baselines/reference/bangInModuleName.types index 06a602e2ff831..93115f76a0ead 100644 --- a/tests/baselines/reference/bangInModuleName.types +++ b/tests/baselines/reference/bangInModuleName.types @@ -1,13 +1,10 @@ === tests/cases/compiler/a.ts === - /// import * as http from 'intern/dojo/node!http'; >http : typeof http === tests/cases/compiler/a.d.ts === - - declare module "http" { } diff --git a/tests/baselines/reference/bestChoiceType.js b/tests/baselines/reference/bestChoiceType.js index 0c1bf5df2d420..edd36f77be96c 100644 --- a/tests/baselines/reference/bestChoiceType.js +++ b/tests/baselines/reference/bestChoiceType.js @@ -1,5 +1,4 @@ //// [bestChoiceType.ts] - // Repro from #10041 (''.match(/ /) || []).map(s => s.toLowerCase()); diff --git a/tests/baselines/reference/bestChoiceType.symbols b/tests/baselines/reference/bestChoiceType.symbols index d6197ad9a6b62..dc4ea663efcec 100644 --- a/tests/baselines/reference/bestChoiceType.symbols +++ b/tests/baselines/reference/bestChoiceType.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/bestChoiceType.ts === - // Repro from #10041 (''.match(/ /) || []).map(s => s.toLowerCase()); @@ -7,57 +6,57 @@ >''.match : Symbol(String.match, Decl(lib.d.ts, --, --)) >match : Symbol(String.match, Decl(lib.d.ts, --, --)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 3, 26)) +>s : Symbol(s, Decl(bestChoiceType.ts, 2, 26)) >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 3, 26)) +>s : Symbol(s, Decl(bestChoiceType.ts, 2, 26)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) // Similar cases function f1() { ->f1 : Symbol(f1, Decl(bestChoiceType.ts, 3, 48)) +>f1 : Symbol(f1, Decl(bestChoiceType.ts, 2, 48)) let x = ''.match(/ /); ->x : Symbol(x, Decl(bestChoiceType.ts, 8, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 7, 7)) >''.match : Symbol(String.match, Decl(lib.d.ts, --, --)) >match : Symbol(String.match, Decl(lib.d.ts, --, --)) let y = x || []; ->y : Symbol(y, Decl(bestChoiceType.ts, 9, 7)) ->x : Symbol(x, Decl(bestChoiceType.ts, 8, 7)) +>y : Symbol(y, Decl(bestChoiceType.ts, 8, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 7, 7)) let z = y.map(s => s.toLowerCase()); ->z : Symbol(z, Decl(bestChoiceType.ts, 10, 7)) +>z : Symbol(z, Decl(bestChoiceType.ts, 9, 7)) >y.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->y : Symbol(y, Decl(bestChoiceType.ts, 9, 7)) +>y : Symbol(y, Decl(bestChoiceType.ts, 8, 7)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 10, 18)) +>s : Symbol(s, Decl(bestChoiceType.ts, 9, 18)) >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 10, 18)) +>s : Symbol(s, Decl(bestChoiceType.ts, 9, 18)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) } function f2() { ->f2 : Symbol(f2, Decl(bestChoiceType.ts, 11, 1)) +>f2 : Symbol(f2, Decl(bestChoiceType.ts, 10, 1)) let x = ''.match(/ /); ->x : Symbol(x, Decl(bestChoiceType.ts, 14, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 13, 7)) >''.match : Symbol(String.match, Decl(lib.d.ts, --, --)) >match : Symbol(String.match, Decl(lib.d.ts, --, --)) let y = x ? x : []; ->y : Symbol(y, Decl(bestChoiceType.ts, 15, 7)) ->x : Symbol(x, Decl(bestChoiceType.ts, 14, 7)) ->x : Symbol(x, Decl(bestChoiceType.ts, 14, 7)) +>y : Symbol(y, Decl(bestChoiceType.ts, 14, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 13, 7)) +>x : Symbol(x, Decl(bestChoiceType.ts, 13, 7)) let z = y.map(s => s.toLowerCase()); ->z : Symbol(z, Decl(bestChoiceType.ts, 16, 7)) +>z : Symbol(z, Decl(bestChoiceType.ts, 15, 7)) >y.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->y : Symbol(y, Decl(bestChoiceType.ts, 15, 7)) +>y : Symbol(y, Decl(bestChoiceType.ts, 14, 7)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 16, 18)) +>s : Symbol(s, Decl(bestChoiceType.ts, 15, 18)) >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(bestChoiceType.ts, 16, 18)) +>s : Symbol(s, Decl(bestChoiceType.ts, 15, 18)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/bestChoiceType.types b/tests/baselines/reference/bestChoiceType.types index 1aa35c8da9e6d..c4728de2ff162 100644 --- a/tests/baselines/reference/bestChoiceType.types +++ b/tests/baselines/reference/bestChoiceType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/bestChoiceType.ts === - // Repro from #10041 (''.match(/ /) || []).map(s => s.toLowerCase()); diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.js b/tests/baselines/reference/bestCommonTypeReturnStatement.js index 6d6f73bc0cfd6..f4ab98ed1c68a 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.js +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.js @@ -1,5 +1,4 @@ //// [bestCommonTypeReturnStatement.ts] - interface IPromise { then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise; } diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.symbols b/tests/baselines/reference/bestCommonTypeReturnStatement.symbols index db5fb4cfbcd78..8031ffee06f43 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.symbols +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/bestCommonTypeReturnStatement.ts === - interface IPromise { >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) ->T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19)) +>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 0, 19)) then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise; ->then : Symbol(IPromise.then, Decl(bestCommonTypeReturnStatement.ts, 1, 23)) ->successCallback : Symbol(successCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 9)) ->promiseValue : Symbol(promiseValue, Decl(bestCommonTypeReturnStatement.ts, 2, 27)) ->T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19)) ->errorCallback : Symbol(errorCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 51)) ->reason : Symbol(reason, Decl(bestCommonTypeReturnStatement.ts, 2, 69)) +>then : Symbol(IPromise.then, Decl(bestCommonTypeReturnStatement.ts, 0, 23)) +>successCallback : Symbol(successCallback, Decl(bestCommonTypeReturnStatement.ts, 1, 9)) +>promiseValue : Symbol(promiseValue, Decl(bestCommonTypeReturnStatement.ts, 1, 27)) +>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 0, 19)) +>errorCallback : Symbol(errorCallback, Decl(bestCommonTypeReturnStatement.ts, 1, 51)) +>reason : Symbol(reason, Decl(bestCommonTypeReturnStatement.ts, 1, 69)) >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) } function f() { ->f : Symbol(f, Decl(bestCommonTypeReturnStatement.ts, 3, 1)) +>f : Symbol(f, Decl(bestCommonTypeReturnStatement.ts, 2, 1)) if (true) return b(); ->b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1)) +>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 7, 1)) return d(); ->d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45)) +>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 10, 45)) } function b(): IPromise { return null; } ->b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1)) +>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 7, 1)) >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) function d(): IPromise { return null; } ->d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45)) +>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 10, 45)) >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.types b/tests/baselines/reference/bestCommonTypeReturnStatement.types index b327e707350cc..3cc3a22121266 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.types +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.types @@ -1,5 +1,4 @@ === tests/cases/compiler/bestCommonTypeReturnStatement.ts === - interface IPromise { >IPromise : IPromise >T : T diff --git a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt index c3e9f220a3ad8..411c7099f1149 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt +++ b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(35,24): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(36,24): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(34,24): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(35,24): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(46,26): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(46,33): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,26): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,33): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,26): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,33): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(49,26): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(49,38): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,33): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,26): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,38): error TS2532: Object is possibly 'undefined'. ==== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts (8 errors) ==== - // ~ operator on any type var ANY: any; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.js b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.js index 860dbc68a53ab..0236bd736ee94 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithAnyOtherType.ts] - // ~ operator on any type var ANY: any; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.js b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.js index cd0e967b66f52..b35a5e4ba1226 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithBooleanType.ts] - // ~ operator on boolean type var BOOLEAN: boolean; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols index ad30b16dd0817..d52e73ba60086 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols +++ b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols @@ -1,90 +1,89 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithBooleanType.ts === - // ~ operator on boolean type var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 3)) function foo(): boolean { return true; } ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 21)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 21)) class A { ->A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 4, 40)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 3, 40)) public a: boolean; ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) static foo() { return false; } ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 7, 22)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 22)) } module M { ->M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 9, 1)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 8, 1)) export var n: boolean; ->n : Symbol(n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) } var objA = new A(); ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 14, 3)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 4, 40)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 13, 3)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 3, 40)) // boolean type var var ResultIsNumber1 = ~BOOLEAN; ->ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithBooleanType.ts, 17, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 3)) +>ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithBooleanType.ts, 16, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 3)) // boolean type literal var ResultIsNumber2 = ~true; ->ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 3)) +>ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithBooleanType.ts, 19, 3)) var ResultIsNumber3 = ~{ x: true, y: false }; ->ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithBooleanType.ts, 21, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithBooleanType.ts, 21, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithBooleanType.ts, 21, 33)) +>ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 33)) // boolean type expressions var ResultIsNumber4 = ~objA.a; ->ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithBooleanType.ts, 24, 3)) ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 14, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) +>ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithBooleanType.ts, 23, 3)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 13, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) var ResultIsNumber5 = ~M.n; ->ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithBooleanType.ts, 25, 3)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 9, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) +>ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithBooleanType.ts, 24, 3)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 8, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) var ResultIsNumber6 = ~foo(); ->ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithBooleanType.ts, 26, 3)) ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 21)) +>ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithBooleanType.ts, 25, 3)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 21)) var ResultIsNumber7 = ~A.foo(); ->ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithBooleanType.ts, 27, 3)) ->A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 7, 22)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 4, 40)) ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 7, 22)) +>ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithBooleanType.ts, 26, 3)) +>A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 22)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithBooleanType.ts, 3, 40)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 22)) // multiple ~ operators var ResultIsNumber8 = ~~BOOLEAN; ->ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithBooleanType.ts, 30, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 3)) +>ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithBooleanType.ts, 29, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 3)) // miss assignment operators ~true; ~BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 3)) ~foo(); ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 2, 21)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithBooleanType.ts, 1, 21)) ~true, false; ~objA.a; ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 14, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 6, 9)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithBooleanType.ts, 13, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithBooleanType.ts, 5, 9)) ~M.n; ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 9, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 11, 14)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithBooleanType.ts, 8, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithBooleanType.ts, 10, 14)) diff --git a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types index ccdc6a7bf0cde..2875a46355c71 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types +++ b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithBooleanType.ts === - // ~ operator on boolean type var BOOLEAN: boolean; >BOOLEAN : boolean diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js index a270fc98c5194..0bcf2fa39569b 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithEnumType.ts] - // ~ operator on enum type enum ENUM1 { A, B, "" }; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.symbols index 6bd0aa8ad5578..24783a153ae88 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.symbols +++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.symbols @@ -1,39 +1,38 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts === - // ~ operator on enum type enum ENUM1 { A, B, "" }; >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) ->B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) +>B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) // enum type var var ResultIsNumber1 = ~ENUM1; ->ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithEnumType.ts, 6, 3)) +>ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithEnumType.ts, 5, 3)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) // enum type expressions var ResultIsNumber2 = ~ENUM1["A"]; ->ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithEnumType.ts, 9, 3)) +>ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithEnumType.ts, 8, 3)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) var ResultIsNumber3 = ~(ENUM1.A + ENUM1["B"]); ->ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithEnumType.ts, 10, 3)) ->ENUM1.A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithEnumType.ts, 9, 3)) +>ENUM1.A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"B" : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>"B" : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) // multiple ~ operators var ResultIsNumber4 = ~~~(ENUM1["A"] + ENUM1.B); ->ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithEnumType.ts, 13, 3)) +>ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithEnumType.ts, 12, 3)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) ->ENUM1.B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) +>ENUM1.B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>B : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) // miss assignment operators ~ENUM1; @@ -41,12 +40,12 @@ var ResultIsNumber4 = ~~~(ENUM1["A"] + ENUM1.B); ~ENUM1["A"]; >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>"A" : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) ~ENUM1.A, ~ENUM1["B"]; ->ENUM1.A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>ENUM1.A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 12)) +>A : Symbol(ENUM1.A, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 12)) >ENUM1 : Symbol(ENUM1, Decl(bitwiseNotOperatorWithEnumType.ts, 0, 0)) ->"B" : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 3, 15)) +>"B" : Symbol(ENUM1.B, Decl(bitwiseNotOperatorWithEnumType.ts, 2, 15)) diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types index 53d44f584eaa2..03008f67d110b 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types +++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts === - // ~ operator on enum type enum ENUM1 { A, B, "" }; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.js b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.js index b6660f677c7be..aab04be6dfc90 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithNumberType.ts] - // ~ operator on number type var NUMBER: number; var NUMBER1: number[] = [1, 2]; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols index 8ce159b9171b6..f7dd03d78c3e9 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols +++ b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols @@ -1,127 +1,126 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithNumberType.ts === - // ~ operator on number type var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) var NUMBER1: number[] = [1, 2]; ->NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 3)) +>NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) function foo(): number { return 1; } ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 31)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 31)) class A { ->A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 5, 36)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 4, 36)) public a: number; ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) static foo() { return 1; } ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 8, 21)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 21)) } module M { ->M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 10, 1)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 9, 1)) export var n: number; ->n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) } var objA = new A(); ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 15, 3)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 5, 36)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 14, 3)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 4, 36)) // number type var var ResultIsNumber1 = ~NUMBER; ->ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithNumberType.ts, 18, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithNumberType.ts, 17, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) var ResultIsNumber2 = ~NUMBER1; ->ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithNumberType.ts, 19, 3)) ->NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 3)) +>ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithNumberType.ts, 18, 3)) +>NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) // number type literal var ResultIsNumber3 = ~1; ->ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 3)) +>ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithNumberType.ts, 21, 3)) var ResultIsNumber4 = ~{ x: 1, y: 2}; ->ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 30)) +>ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 30)) var ResultIsNumber5 = ~{ x: 1, y: (n: number) => { return n; } }; ->ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 30)) ->n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 35)) ->n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 24, 35)) +>ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 30)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 35)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 35)) // number type expressions var ResultIsNumber6 = ~objA.a; ->ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithNumberType.ts, 27, 3)) ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) +>ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithNumberType.ts, 26, 3)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) var ResultIsNumber7 = ~M.n; ->ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithNumberType.ts, 28, 3)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) +>ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithNumberType.ts, 27, 3)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) var ResultIsNumber8 = ~NUMBER1[0]; ->ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithNumberType.ts, 29, 3)) ->NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 3)) +>ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithNumberType.ts, 28, 3)) +>NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) var ResultIsNumber9 = ~foo(); ->ResultIsNumber9 : Symbol(ResultIsNumber9, Decl(bitwiseNotOperatorWithNumberType.ts, 30, 3)) ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 31)) +>ResultIsNumber9 : Symbol(ResultIsNumber9, Decl(bitwiseNotOperatorWithNumberType.ts, 29, 3)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 31)) var ResultIsNumber10 = ~A.foo(); ->ResultIsNumber10 : Symbol(ResultIsNumber10, Decl(bitwiseNotOperatorWithNumberType.ts, 31, 3)) ->A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 8, 21)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 5, 36)) ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 8, 21)) +>ResultIsNumber10 : Symbol(ResultIsNumber10, Decl(bitwiseNotOperatorWithNumberType.ts, 30, 3)) +>A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 21)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithNumberType.ts, 4, 36)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 21)) var ResultIsNumber11 = ~(NUMBER + NUMBER); ->ResultIsNumber11 : Symbol(ResultIsNumber11, Decl(bitwiseNotOperatorWithNumberType.ts, 32, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>ResultIsNumber11 : Symbol(ResultIsNumber11, Decl(bitwiseNotOperatorWithNumberType.ts, 31, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) // multiple ~ operators var ResultIsNumber12 = ~~NUMBER; ->ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithNumberType.ts, 35, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithNumberType.ts, 34, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) var ResultIsNumber13 = ~~~(NUMBER + NUMBER); ->ResultIsNumber13 : Symbol(ResultIsNumber13, Decl(bitwiseNotOperatorWithNumberType.ts, 36, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>ResultIsNumber13 : Symbol(ResultIsNumber13, Decl(bitwiseNotOperatorWithNumberType.ts, 35, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) // miss assignment operators ~NUMBER; ->NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(bitwiseNotOperatorWithNumberType.ts, 1, 3)) ~NUMBER1; ->NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 3)) +>NUMBER1 : Symbol(NUMBER1, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 3)) ~foo(); ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 3, 31)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithNumberType.ts, 2, 31)) ~objA.a; ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) ~M.n; ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) ~objA.a, M.n; ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 7, 9)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 12, 14)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithNumberType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithNumberType.ts, 6, 9)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithNumberType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithNumberType.ts, 11, 14)) diff --git a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.types b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.types index 880ef82b953ec..8dc3c31867fc3 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.types +++ b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithNumberType.ts === - // ~ operator on number type var NUMBER: number; >NUMBER : number diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.js b/tests/baselines/reference/bitwiseNotOperatorWithStringType.js index b1c3b41f28666..366af5ecea8dd 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.js @@ -1,5 +1,4 @@ //// [bitwiseNotOperatorWithStringType.ts] - // ~ operator on string type var STRING: string; var STRING1: string[] = ["", "abc"]; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols index 06f848c74504f..f535acc199b30 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols +++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols @@ -1,123 +1,122 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithStringType.ts === - // ~ operator on string type var STRING: string; ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) var STRING1: string[] = ["", "abc"]; ->STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 3, 3)) +>STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) function foo(): string { return "abc"; } ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 3, 36)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 2, 36)) class A { ->A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 5, 40)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 4, 40)) public a: string; ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) static foo() { return ""; } ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 8, 21)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 7, 21)) } module M { ->M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 10, 1)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 9, 1)) export var n: string; ->n : Symbol(n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) +>n : Symbol(n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) } var objA = new A(); ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 15, 3)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 5, 40)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 14, 3)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 4, 40)) // string type var var ResultIsNumber1 = ~STRING; ->ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithStringType.ts, 18, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithStringType.ts, 17, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) var ResultIsNumber2 = ~STRING1; ->ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithStringType.ts, 19, 3)) ->STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 3, 3)) +>ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithStringType.ts, 18, 3)) +>STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) // string type literal var ResultIsNumber3 = ~""; ->ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithStringType.ts, 22, 3)) +>ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithStringType.ts, 21, 3)) var ResultIsNumber4 = ~{ x: "", y: "" }; ->ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithStringType.ts, 23, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 23, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 23, 31)) +>ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithStringType.ts, 22, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 22, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 22, 31)) var ResultIsNumber5 = ~{ x: "", y: (s: string) => { return s; } }; ->ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithStringType.ts, 24, 3)) ->x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 24, 24)) ->y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 24, 31)) ->s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 24, 36)) ->s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 24, 36)) +>ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithStringType.ts, 23, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 23, 24)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 23, 31)) +>s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 23, 36)) +>s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 23, 36)) // string type expressions var ResultIsNumber6 = ~objA.a; ->ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithStringType.ts, 27, 3)) ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) +>ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithStringType.ts, 26, 3)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) var ResultIsNumber7 = ~M.n; ->ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithStringType.ts, 28, 3)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) +>ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithStringType.ts, 27, 3)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) var ResultIsNumber8 = ~STRING1[0]; ->ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithStringType.ts, 29, 3)) ->STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 3, 3)) +>ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithStringType.ts, 28, 3)) +>STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) var ResultIsNumber9 = ~foo(); ->ResultIsNumber9 : Symbol(ResultIsNumber9, Decl(bitwiseNotOperatorWithStringType.ts, 30, 3)) ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 3, 36)) +>ResultIsNumber9 : Symbol(ResultIsNumber9, Decl(bitwiseNotOperatorWithStringType.ts, 29, 3)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 2, 36)) var ResultIsNumber10 = ~A.foo(); ->ResultIsNumber10 : Symbol(ResultIsNumber10, Decl(bitwiseNotOperatorWithStringType.ts, 31, 3)) ->A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 8, 21)) ->A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 5, 40)) ->foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 8, 21)) +>ResultIsNumber10 : Symbol(ResultIsNumber10, Decl(bitwiseNotOperatorWithStringType.ts, 30, 3)) +>A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 7, 21)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithStringType.ts, 4, 40)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithStringType.ts, 7, 21)) var ResultIsNumber11 = ~(STRING + STRING); ->ResultIsNumber11 : Symbol(ResultIsNumber11, Decl(bitwiseNotOperatorWithStringType.ts, 32, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>ResultIsNumber11 : Symbol(ResultIsNumber11, Decl(bitwiseNotOperatorWithStringType.ts, 31, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) var ResultIsNumber12 = ~STRING.charAt(0); ->ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithStringType.ts, 33, 3)) +>ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithStringType.ts, 32, 3)) >STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) // multiple ~ operators var ResultIsNumber13 = ~~STRING; ->ResultIsNumber13 : Symbol(ResultIsNumber13, Decl(bitwiseNotOperatorWithStringType.ts, 36, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>ResultIsNumber13 : Symbol(ResultIsNumber13, Decl(bitwiseNotOperatorWithStringType.ts, 35, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) var ResultIsNumber14 = ~~~(STRING + STRING); ->ResultIsNumber14 : Symbol(ResultIsNumber14, Decl(bitwiseNotOperatorWithStringType.ts, 37, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>ResultIsNumber14 : Symbol(ResultIsNumber14, Decl(bitwiseNotOperatorWithStringType.ts, 36, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) //miss assignment operators ~STRING; ->STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) ~STRING1; ->STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 3, 3)) +>STRING1 : Symbol(STRING1, Decl(bitwiseNotOperatorWithStringType.ts, 2, 3)) ~foo(); ->foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 3, 36)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithStringType.ts, 2, 36)) ~objA.a,M.n; ->objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) ->objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 15, 3)) ->a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 7, 9)) ->M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) ->M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 10, 1)) ->n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 12, 14)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithStringType.ts, 14, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithStringType.ts, 6, 9)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithStringType.ts, 9, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithStringType.ts, 11, 14)) diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.types b/tests/baselines/reference/bitwiseNotOperatorWithStringType.types index 17a7fc8b6ec93..130b52c84717d 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.types +++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithStringType.ts === - // ~ operator on string type var STRING: string; >STRING : string diff --git a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.js b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.js index d299aaa8452f9..60ecfad3bc9ea 100644 --- a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.js +++ b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.js @@ -1,5 +1,4 @@ //// [blockScopedBindingsReassignedInLoop3.ts] - for (let x = 1, y = 2; x < y; ++x, --y) { let a = () => x++ + y++; if (x == 1) { diff --git a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.symbols b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.symbols index f78cd684c3a38..71e251f2dc353 100644 --- a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.symbols +++ b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.symbols @@ -1,203 +1,202 @@ === tests/cases/compiler/blockScopedBindingsReassignedInLoop3.ts === - for (let x = 1, y = 2; x < y; ++x, --y) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) let a = () => x++ + y++; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 2, 7)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 7)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) if (x == 1) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) break; } else { for (let a = 1; a < 5; --a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) let f = () => a; ->f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 8, 15)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) +>f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) if (a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) a = x; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 7, 16)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 8)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 6, 16)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 8)) break; } else { y++; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) } } y = 5; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 1, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 0, 15)) } } for (let x = 1, y = 2; x < y; ++x, --y) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) let a = () => x++ + y++; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 24, 7)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 7)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) if (x == 1) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) continue; } else { for (let a = 1; a < 5; --a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) let f = () => a; ->f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 30, 15)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) +>f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) if (a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) a = x; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 29, 16)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 8)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 28, 16)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 8)) continue; } else { y++; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) } } y = 5; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 23, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 22, 15)) } } loop2: for (let x = 1, y = 2; x < y; ++x, --y) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) let a = () => x++ + y++; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 46, 7)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 7)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) if (x == 1) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) break loop2; } else { loop1: for (let a = 1; a < 5; --a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) let f = () => a; ->f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 53, 15)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) +>f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) if (a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) a = x; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 52, 16)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 8)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 51, 16)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 8)) break loop1; } else { y++; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) break loop2 } } y = 5; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 45, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 44, 15)) } } loop2: for (let x = 1, y = 2; x < y; ++x, --y) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) let a = () => x++ + y++; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 70, 7)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 7)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) if (x == 1) { ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) continue loop2; } else { loop1: for (let a = 1; a < 5; --a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) let f = () => a; ->f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 77, 15)) ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) +>f : Symbol(f, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 15)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) if (a) { ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) a = x; ->a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 76, 16)) ->x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 8)) +>a : Symbol(a, Decl(blockScopedBindingsReassignedInLoop3.ts, 75, 16)) +>x : Symbol(x, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 8)) continue loop1; } else { y++; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) continue loop2 } } y = 5; ->y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 69, 15)) +>y : Symbol(y, Decl(blockScopedBindingsReassignedInLoop3.ts, 68, 15)) } } diff --git a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.types b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.types index 3dab1458b6740..a61137b3e3aba 100644 --- a/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.types +++ b/tests/baselines/reference/blockScopedBindingsReassignedInLoop3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/blockScopedBindingsReassignedInLoop3.ts === - for (let x = 1, y = 2; x < y; ++x, --y) { >x : number >1 : 1 diff --git a/tests/baselines/reference/booleanLiteralTypes2.js b/tests/baselines/reference/booleanLiteralTypes2.js index 7ef643593a684..19bac7c362c5b 100644 --- a/tests/baselines/reference/booleanLiteralTypes2.js +++ b/tests/baselines/reference/booleanLiteralTypes2.js @@ -1,5 +1,4 @@ //// [booleanLiteralTypes2.ts] - type A1 = true | false; type A2 = false | true; diff --git a/tests/baselines/reference/booleanLiteralTypes2.symbols b/tests/baselines/reference/booleanLiteralTypes2.symbols index 1f64767cbb4d7..ad3e90ad3f805 100644 --- a/tests/baselines/reference/booleanLiteralTypes2.symbols +++ b/tests/baselines/reference/booleanLiteralTypes2.symbols @@ -1,141 +1,140 @@ === tests/cases/conformance/types/literal/booleanLiteralTypes2.ts === - type A1 = true | false; >A1 : Symbol(A1, Decl(booleanLiteralTypes2.ts, 0, 0)) type A2 = false | true; ->A2 : Symbol(A2, Decl(booleanLiteralTypes2.ts, 1, 23)) +>A2 : Symbol(A2, Decl(booleanLiteralTypes2.ts, 0, 23)) function f1() { ->f1 : Symbol(f1, Decl(booleanLiteralTypes2.ts, 2, 23)) +>f1 : Symbol(f1, Decl(booleanLiteralTypes2.ts, 1, 23)) var a: A1; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7), Decl(booleanLiteralTypes2.ts, 8, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 4, 7), Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7)) >A1 : Symbol(A1, Decl(booleanLiteralTypes2.ts, 0, 0)) var a: A2; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7), Decl(booleanLiteralTypes2.ts, 8, 7)) ->A2 : Symbol(A2, Decl(booleanLiteralTypes2.ts, 1, 23)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 4, 7), Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7)) +>A2 : Symbol(A2, Decl(booleanLiteralTypes2.ts, 0, 23)) var a: true | false; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7), Decl(booleanLiteralTypes2.ts, 8, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 4, 7), Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7)) var a: false | true; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7), Decl(booleanLiteralTypes2.ts, 8, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 4, 7), Decl(booleanLiteralTypes2.ts, 5, 7), Decl(booleanLiteralTypes2.ts, 6, 7), Decl(booleanLiteralTypes2.ts, 7, 7)) } function f2(a: true | false, b: boolean) { ->f2 : Symbol(f2, Decl(booleanLiteralTypes2.ts, 9, 1)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 11, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 11, 28)) +>f2 : Symbol(f2, Decl(booleanLiteralTypes2.ts, 8, 1)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 10, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 10, 28)) a = b; ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 11, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 11, 28)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 10, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 10, 28)) b = a; ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 11, 28)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 11, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 10, 28)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 10, 12)) } function f3(a: true | false, b: true | false) { ->f3 : Symbol(f3, Decl(booleanLiteralTypes2.ts, 14, 1)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 16, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 16, 28)) +>f3 : Symbol(f3, Decl(booleanLiteralTypes2.ts, 13, 1)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 15, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 15, 28)) var x = a || b; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7), Decl(booleanLiteralTypes2.ts, 19, 7)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 16, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 16, 28)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 16, 7), Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 15, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 15, 28)) var x = a && b; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7), Decl(booleanLiteralTypes2.ts, 19, 7)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 16, 12)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 16, 28)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 16, 7), Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 15, 12)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 15, 28)) var x = !a; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7), Decl(booleanLiteralTypes2.ts, 19, 7)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 16, 12)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 16, 7), Decl(booleanLiteralTypes2.ts, 17, 7), Decl(booleanLiteralTypes2.ts, 18, 7)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 15, 12)) } function f4(t: true, f: false) { ->f4 : Symbol(f4, Decl(booleanLiteralTypes2.ts, 20, 1)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) +>f4 : Symbol(f4, Decl(booleanLiteralTypes2.ts, 19, 1)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) var x1 = t && f; ->x1 : Symbol(x1, Decl(booleanLiteralTypes2.ts, 23, 7)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) +>x1 : Symbol(x1, Decl(booleanLiteralTypes2.ts, 22, 7)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) var x2 = f && t; ->x2 : Symbol(x2, Decl(booleanLiteralTypes2.ts, 24, 7)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) +>x2 : Symbol(x2, Decl(booleanLiteralTypes2.ts, 23, 7)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) var x3 = t || f; ->x3 : Symbol(x3, Decl(booleanLiteralTypes2.ts, 25, 7)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) +>x3 : Symbol(x3, Decl(booleanLiteralTypes2.ts, 24, 7)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) var x4 = f || t; ->x4 : Symbol(x4, Decl(booleanLiteralTypes2.ts, 26, 7)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) +>x4 : Symbol(x4, Decl(booleanLiteralTypes2.ts, 25, 7)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) var x5 = !t; ->x5 : Symbol(x5, Decl(booleanLiteralTypes2.ts, 27, 7)) ->t : Symbol(t, Decl(booleanLiteralTypes2.ts, 22, 12)) +>x5 : Symbol(x5, Decl(booleanLiteralTypes2.ts, 26, 7)) +>t : Symbol(t, Decl(booleanLiteralTypes2.ts, 21, 12)) var x6 = !f; ->x6 : Symbol(x6, Decl(booleanLiteralTypes2.ts, 28, 7)) ->f : Symbol(f, Decl(booleanLiteralTypes2.ts, 22, 20)) +>x6 : Symbol(x6, Decl(booleanLiteralTypes2.ts, 27, 7)) +>f : Symbol(f, Decl(booleanLiteralTypes2.ts, 21, 20)) } declare function g(x: true): string; ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 31, 19)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 30, 19)) declare function g(x: false): boolean; ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 32, 19)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 31, 19)) declare function g(x: boolean): number; ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 33, 19)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 32, 19)) function f5(b: boolean) { ->f5 : Symbol(f5, Decl(booleanLiteralTypes2.ts, 33, 39)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 35, 12)) +>f5 : Symbol(f5, Decl(booleanLiteralTypes2.ts, 32, 39)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 34, 12)) var z1 = g(true); ->z1 : Symbol(z1, Decl(booleanLiteralTypes2.ts, 36, 7)) ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) +>z1 : Symbol(z1, Decl(booleanLiteralTypes2.ts, 35, 7)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) var z2 = g(false); ->z2 : Symbol(z2, Decl(booleanLiteralTypes2.ts, 37, 7)) ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) +>z2 : Symbol(z2, Decl(booleanLiteralTypes2.ts, 36, 7)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) var z3 = g(b); ->z3 : Symbol(z3, Decl(booleanLiteralTypes2.ts, 38, 7)) ->g : Symbol(g, Decl(booleanLiteralTypes2.ts, 29, 1), Decl(booleanLiteralTypes2.ts, 31, 36), Decl(booleanLiteralTypes2.ts, 32, 38)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 35, 12)) +>z3 : Symbol(z3, Decl(booleanLiteralTypes2.ts, 37, 7)) +>g : Symbol(g, Decl(booleanLiteralTypes2.ts, 28, 1), Decl(booleanLiteralTypes2.ts, 30, 36), Decl(booleanLiteralTypes2.ts, 31, 38)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 34, 12)) } function assertNever(x: never): never { ->assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 39, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 41, 21)) +>assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 38, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 40, 21)) throw new Error("Unexpected value"); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function f10(x: true | false) { ->f10 : Symbol(f10, Decl(booleanLiteralTypes2.ts, 43, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 45, 13)) +>f10 : Symbol(f10, Decl(booleanLiteralTypes2.ts, 42, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 44, 13)) switch (x) { ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 45, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 44, 13)) case true: return "true"; case false: return "false"; @@ -143,106 +142,106 @@ function f10(x: true | false) { } function f11(x: true | false) { ->f11 : Symbol(f11, Decl(booleanLiteralTypes2.ts, 50, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 52, 13)) +>f11 : Symbol(f11, Decl(booleanLiteralTypes2.ts, 49, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 51, 13)) switch (x) { ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 52, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 51, 13)) case true: return "true"; case false: return "false"; } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 39, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 52, 13)) +>assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 38, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 51, 13)) } function f12(x: true | false) { ->f12 : Symbol(f12, Decl(booleanLiteralTypes2.ts, 58, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 60, 13)) +>f12 : Symbol(f12, Decl(booleanLiteralTypes2.ts, 57, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 59, 13)) if (x) { ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 60, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 59, 13)) x; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 60, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 59, 13)) } else { x; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 60, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 59, 13)) } } function f13(x: true | false) { ->f13 : Symbol(f13, Decl(booleanLiteralTypes2.ts, 67, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 69, 13)) +>f13 : Symbol(f13, Decl(booleanLiteralTypes2.ts, 66, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 68, 13)) if (x === true) { ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 69, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 68, 13)) x; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 69, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 68, 13)) } else { x; ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 69, 13)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 68, 13)) } } type Item = ->Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 76, 1)) +>Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 75, 1)) { kind: true, a: string } | ->kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) +>kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) { kind: false, b: string }; ->kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 80, 5)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) +>kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) function f20(x: Item) { ->f20 : Symbol(f20, Decl(booleanLiteralTypes2.ts, 80, 31)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 82, 13)) ->Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 76, 1)) +>f20 : Symbol(f20, Decl(booleanLiteralTypes2.ts, 79, 31)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 81, 13)) +>Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 75, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5), Decl(booleanLiteralTypes2.ts, 80, 5)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 82, 13)) ->kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5), Decl(booleanLiteralTypes2.ts, 80, 5)) +>x.kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5), Decl(booleanLiteralTypes2.ts, 79, 5)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 81, 13)) +>kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5), Decl(booleanLiteralTypes2.ts, 79, 5)) case true: return x.a; ->x.a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 82, 13)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) +>x.a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 81, 13)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) case false: return x.b; ->x.b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 82, 13)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) +>x.b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 81, 13)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) } } function f21(x: Item) { ->f21 : Symbol(f21, Decl(booleanLiteralTypes2.ts, 87, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) ->Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 76, 1)) +>f21 : Symbol(f21, Decl(booleanLiteralTypes2.ts, 86, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) +>Item : Symbol(Item, Decl(booleanLiteralTypes2.ts, 75, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5), Decl(booleanLiteralTypes2.ts, 80, 5)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) ->kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 79, 5), Decl(booleanLiteralTypes2.ts, 80, 5)) +>x.kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5), Decl(booleanLiteralTypes2.ts, 79, 5)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) +>kind : Symbol(kind, Decl(booleanLiteralTypes2.ts, 78, 5), Decl(booleanLiteralTypes2.ts, 79, 5)) case true: return x.a; ->x.a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) ->a : Symbol(a, Decl(booleanLiteralTypes2.ts, 79, 17)) +>x.a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) +>a : Symbol(a, Decl(booleanLiteralTypes2.ts, 78, 17)) case false: return x.b; ->x.b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) ->b : Symbol(b, Decl(booleanLiteralTypes2.ts, 80, 18)) +>x.b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) +>b : Symbol(b, Decl(booleanLiteralTypes2.ts, 79, 18)) } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 39, 1)) ->x : Symbol(x, Decl(booleanLiteralTypes2.ts, 89, 13)) +>assertNever : Symbol(assertNever, Decl(booleanLiteralTypes2.ts, 38, 1)) +>x : Symbol(x, Decl(booleanLiteralTypes2.ts, 88, 13)) } diff --git a/tests/baselines/reference/booleanLiteralTypes2.types b/tests/baselines/reference/booleanLiteralTypes2.types index e5e4fba7f4f5c..8c0116407cc55 100644 --- a/tests/baselines/reference/booleanLiteralTypes2.types +++ b/tests/baselines/reference/booleanLiteralTypes2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/booleanLiteralTypes2.ts === - type A1 = true | false; >A1 : boolean >true : true diff --git a/tests/baselines/reference/breakTarget3.js b/tests/baselines/reference/breakTarget3.js index b36eeb3902b75..0fa6cd2d2988a 100644 --- a/tests/baselines/reference/breakTarget3.js +++ b/tests/baselines/reference/breakTarget3.js @@ -1,5 +1,4 @@ //// [breakTarget3.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/breakTarget3.symbols b/tests/baselines/reference/breakTarget3.symbols index a0b1743550481..580706bbd4a46 100644 --- a/tests/baselines/reference/breakTarget3.symbols +++ b/tests/baselines/reference/breakTarget3.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/breakTarget3.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target1; diff --git a/tests/baselines/reference/breakTarget3.types b/tests/baselines/reference/breakTarget3.types index 6e926768e12a5..83065c8929b0f 100644 --- a/tests/baselines/reference/breakTarget3.types +++ b/tests/baselines/reference/breakTarget3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/breakTarget3.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/breakTarget4.js b/tests/baselines/reference/breakTarget4.js index 0c91e44ecbdf9..4586301d71b7c 100644 --- a/tests/baselines/reference/breakTarget4.js +++ b/tests/baselines/reference/breakTarget4.js @@ -1,5 +1,4 @@ //// [breakTarget4.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/breakTarget4.symbols b/tests/baselines/reference/breakTarget4.symbols index d4edcb17e1afd..aba35ddcfdf3d 100644 --- a/tests/baselines/reference/breakTarget4.symbols +++ b/tests/baselines/reference/breakTarget4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/breakTarget4.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target2; diff --git a/tests/baselines/reference/breakTarget4.types b/tests/baselines/reference/breakTarget4.types index 80bee56f9c737..d183879a47b58 100644 --- a/tests/baselines/reference/breakTarget4.types +++ b/tests/baselines/reference/breakTarget4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/breakTarget4.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/breakTarget5.errors.txt b/tests/baselines/reference/breakTarget5.errors.txt index d92f29d67eea7..a54a415b9907b 100644 --- a/tests/baselines/reference/breakTarget5.errors.txt +++ b/tests/baselines/reference/breakTarget5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/breakTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary. +tests/cases/compiler/breakTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary. ==== tests/cases/compiler/breakTarget5.ts (1 errors) ==== - target: while (true) { function f() { diff --git a/tests/baselines/reference/breakTarget5.js b/tests/baselines/reference/breakTarget5.js index 9f6b063a8c4ea..197e4e147bd7e 100644 --- a/tests/baselines/reference/breakTarget5.js +++ b/tests/baselines/reference/breakTarget5.js @@ -1,5 +1,4 @@ //// [breakTarget5.ts] - target: while (true) { function f() { diff --git a/tests/baselines/reference/cacheResolutions.js b/tests/baselines/reference/cacheResolutions.js index 6b28c90e321fe..8c986c8fa14dd 100644 --- a/tests/baselines/reference/cacheResolutions.js +++ b/tests/baselines/reference/cacheResolutions.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cacheResolutions.ts] //// //// [app.ts] - export let x = 1; //// [lib1.ts] diff --git a/tests/baselines/reference/cacheResolutions.symbols b/tests/baselines/reference/cacheResolutions.symbols index 362ce5c308c9f..4b40798149b2d 100644 --- a/tests/baselines/reference/cacheResolutions.symbols +++ b/tests/baselines/reference/cacheResolutions.symbols @@ -1,7 +1,6 @@ === /a/b/c/app.ts === - export let x = 1; ->x : Symbol(x, Decl(app.ts, 1, 10)) +>x : Symbol(x, Decl(app.ts, 0, 10)) === /a/b/c/lib1.ts === export let x = 1; diff --git a/tests/baselines/reference/cacheResolutions.types b/tests/baselines/reference/cacheResolutions.types index fdcc0a6c46c07..59d208b5d22ab 100644 --- a/tests/baselines/reference/cacheResolutions.types +++ b/tests/baselines/reference/cacheResolutions.types @@ -1,5 +1,4 @@ === /a/b/c/app.ts === - export let x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/cachedModuleResolution1.js b/tests/baselines/reference/cachedModuleResolution1.js index d93133cca406e..cd83308f922cf 100644 --- a/tests/baselines/reference/cachedModuleResolution1.js +++ b/tests/baselines/reference/cachedModuleResolution1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution1.ts] //// //// [foo.d.ts] - export declare let x: number //// [app.ts] diff --git a/tests/baselines/reference/cachedModuleResolution1.symbols b/tests/baselines/reference/cachedModuleResolution1.symbols index f7d3c474a56bb..87685f4f14739 100644 --- a/tests/baselines/reference/cachedModuleResolution1.symbols +++ b/tests/baselines/reference/cachedModuleResolution1.symbols @@ -1,7 +1,6 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/d/e/app.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution1.types b/tests/baselines/reference/cachedModuleResolution1.types index c041e8cc340eb..ccc9e1311c83b 100644 --- a/tests/baselines/reference/cachedModuleResolution1.types +++ b/tests/baselines/reference/cachedModuleResolution1.types @@ -1,5 +1,4 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution2.js b/tests/baselines/reference/cachedModuleResolution2.js index c5c3357f65ad1..8ecb42a32ae04 100644 --- a/tests/baselines/reference/cachedModuleResolution2.js +++ b/tests/baselines/reference/cachedModuleResolution2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution2.ts] //// //// [foo.d.ts] - export declare let x: number //// [lib.ts] diff --git a/tests/baselines/reference/cachedModuleResolution2.symbols b/tests/baselines/reference/cachedModuleResolution2.symbols index c8356eadb1193..b9080b03cbfa2 100644 --- a/tests/baselines/reference/cachedModuleResolution2.symbols +++ b/tests/baselines/reference/cachedModuleResolution2.symbols @@ -1,7 +1,6 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/lib.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution2.types b/tests/baselines/reference/cachedModuleResolution2.types index c5069e681c4d7..4c34d48b3a9ed 100644 --- a/tests/baselines/reference/cachedModuleResolution2.types +++ b/tests/baselines/reference/cachedModuleResolution2.types @@ -1,5 +1,4 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution3.js b/tests/baselines/reference/cachedModuleResolution3.js index d476eafd2e8c1..f5da694009969 100644 --- a/tests/baselines/reference/cachedModuleResolution3.js +++ b/tests/baselines/reference/cachedModuleResolution3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution3.ts] //// //// [foo.d.ts] - export declare let x: number //// [app.ts] diff --git a/tests/baselines/reference/cachedModuleResolution3.symbols b/tests/baselines/reference/cachedModuleResolution3.symbols index 799ac6d8d8438..3c5e12431c04c 100644 --- a/tests/baselines/reference/cachedModuleResolution3.symbols +++ b/tests/baselines/reference/cachedModuleResolution3.symbols @@ -1,7 +1,6 @@ === /a/b/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/d/e/app.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution3.types b/tests/baselines/reference/cachedModuleResolution3.types index f87abf1519eb4..412ef2ae1d5c0 100644 --- a/tests/baselines/reference/cachedModuleResolution3.types +++ b/tests/baselines/reference/cachedModuleResolution3.types @@ -1,5 +1,4 @@ === /a/b/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution4.js b/tests/baselines/reference/cachedModuleResolution4.js index 4cc656d73d34c..f5417960d4692 100644 --- a/tests/baselines/reference/cachedModuleResolution4.js +++ b/tests/baselines/reference/cachedModuleResolution4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution4.ts] //// //// [foo.d.ts] - export declare let x: number //// [lib.ts] diff --git a/tests/baselines/reference/cachedModuleResolution4.symbols b/tests/baselines/reference/cachedModuleResolution4.symbols index a30e6bf74e543..a145a1820365e 100644 --- a/tests/baselines/reference/cachedModuleResolution4.symbols +++ b/tests/baselines/reference/cachedModuleResolution4.symbols @@ -1,7 +1,6 @@ === /a/b/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/lib.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution4.types b/tests/baselines/reference/cachedModuleResolution4.types index 3689e57ca6d0e..ca4050e655de1 100644 --- a/tests/baselines/reference/cachedModuleResolution4.types +++ b/tests/baselines/reference/cachedModuleResolution4.types @@ -1,5 +1,4 @@ === /a/b/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution5.js b/tests/baselines/reference/cachedModuleResolution5.js index 35fad11d90e50..4fe641e917e61 100644 --- a/tests/baselines/reference/cachedModuleResolution5.js +++ b/tests/baselines/reference/cachedModuleResolution5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution5.ts] //// //// [foo.d.ts] - export declare let x: number //// [app.ts] diff --git a/tests/baselines/reference/cachedModuleResolution5.symbols b/tests/baselines/reference/cachedModuleResolution5.symbols index eb72f0c7a27dc..6c18677efcfed 100644 --- a/tests/baselines/reference/cachedModuleResolution5.symbols +++ b/tests/baselines/reference/cachedModuleResolution5.symbols @@ -1,7 +1,6 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number ->x : Symbol(x, Decl(foo.d.ts, 1, 18)) +>x : Symbol(x, Decl(foo.d.ts, 0, 18)) === /a/b/c/d/e/app.ts === import {x} from "foo"; diff --git a/tests/baselines/reference/cachedModuleResolution5.types b/tests/baselines/reference/cachedModuleResolution5.types index ad2640402f7c6..e827caaf9228d 100644 --- a/tests/baselines/reference/cachedModuleResolution5.types +++ b/tests/baselines/reference/cachedModuleResolution5.types @@ -1,5 +1,4 @@ === /a/b/node_modules/foo.d.ts === - export declare let x: number >x : number diff --git a/tests/baselines/reference/cachedModuleResolution6.errors.txt b/tests/baselines/reference/cachedModuleResolution6.errors.txt index b272ff29b9d38..7d79a200e11ed 100644 --- a/tests/baselines/reference/cachedModuleResolution6.errors.txt +++ b/tests/baselines/reference/cachedModuleResolution6.errors.txt @@ -1,9 +1,8 @@ -/a/b/c/d/e/app.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. /a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. ==== /a/b/c/d/e/app.ts (1 errors) ==== - import {x} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/cachedModuleResolution6.js b/tests/baselines/reference/cachedModuleResolution6.js index 1e6803b115ca5..364ad55aa6ce1 100644 --- a/tests/baselines/reference/cachedModuleResolution6.js +++ b/tests/baselines/reference/cachedModuleResolution6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution6.ts] //// //// [app.ts] - import {x} from "foo"; //// [lib.ts] diff --git a/tests/baselines/reference/cachedModuleResolution7.errors.txt b/tests/baselines/reference/cachedModuleResolution7.errors.txt index 670c4a665a698..9bc6e3f239cd7 100644 --- a/tests/baselines/reference/cachedModuleResolution7.errors.txt +++ b/tests/baselines/reference/cachedModuleResolution7.errors.txt @@ -1,9 +1,8 @@ /a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. -/a/b/c/lib.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. ==== /a/b/c/lib.ts (1 errors) ==== - import {x} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/cachedModuleResolution7.js b/tests/baselines/reference/cachedModuleResolution7.js index 044eefff73a62..9b103fdd9bf16 100644 --- a/tests/baselines/reference/cachedModuleResolution7.js +++ b/tests/baselines/reference/cachedModuleResolution7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution7.ts] //// //// [lib.ts] - import {x} from "foo"; //// [app.ts] diff --git a/tests/baselines/reference/cachedModuleResolution8.errors.txt b/tests/baselines/reference/cachedModuleResolution8.errors.txt index b272ff29b9d38..7d79a200e11ed 100644 --- a/tests/baselines/reference/cachedModuleResolution8.errors.txt +++ b/tests/baselines/reference/cachedModuleResolution8.errors.txt @@ -1,9 +1,8 @@ -/a/b/c/d/e/app.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. /a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. ==== /a/b/c/d/e/app.ts (1 errors) ==== - import {x} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/cachedModuleResolution8.js b/tests/baselines/reference/cachedModuleResolution8.js index fe89a8f288f45..9e8b67fabf7ae 100644 --- a/tests/baselines/reference/cachedModuleResolution8.js +++ b/tests/baselines/reference/cachedModuleResolution8.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution8.ts] //// //// [app.ts] - import {x} from "foo"; //// [lib.ts] diff --git a/tests/baselines/reference/cachedModuleResolution9.errors.txt b/tests/baselines/reference/cachedModuleResolution9.errors.txt index aeec41f0048f8..482a34cb654f3 100644 --- a/tests/baselines/reference/cachedModuleResolution9.errors.txt +++ b/tests/baselines/reference/cachedModuleResolution9.errors.txt @@ -1,9 +1,8 @@ /a/b/c/d/e/app.ts(1,17): error TS2307: Cannot find module 'foo'. -/a/b/c/lib.ts(2,17): error TS2307: Cannot find module 'foo'. +/a/b/c/lib.ts(1,17): error TS2307: Cannot find module 'foo'. ==== /a/b/c/lib.ts (1 errors) ==== - import {x} from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/cachedModuleResolution9.js b/tests/baselines/reference/cachedModuleResolution9.js index c27ababcb9547..8de0a1ff17340 100644 --- a/tests/baselines/reference/cachedModuleResolution9.js +++ b/tests/baselines/reference/cachedModuleResolution9.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/cachedModuleResolution9.ts] //// //// [lib.ts] - import {x} from "foo"; diff --git a/tests/baselines/reference/callConstructAssignment.errors.txt b/tests/baselines/reference/callConstructAssignment.errors.txt index 62a529daeb199..904d4947a3460 100644 --- a/tests/baselines/reference/callConstructAssignment.errors.txt +++ b/tests/baselines/reference/callConstructAssignment.errors.txt @@ -1,12 +1,10 @@ -tests/cases/compiler/callConstructAssignment.ts(7,1): error TS2322: Type 'new () => any' is not assignable to type '() => void'. +tests/cases/compiler/callConstructAssignment.ts(5,1): error TS2322: Type 'new () => any' is not assignable to type '() => void'. Type 'new () => any' provides no match for the signature '(): void'. -tests/cases/compiler/callConstructAssignment.ts(8,1): error TS2322: Type '() => void' is not assignable to type 'new () => any'. +tests/cases/compiler/callConstructAssignment.ts(6,1): error TS2322: Type '() => void' is not assignable to type 'new () => any'. Type '() => void' provides no match for the signature 'new (): any'. ==== tests/cases/compiler/callConstructAssignment.ts (2 errors) ==== - - var foo:{ ( ):void; } var bar:{ new ( ):any; } diff --git a/tests/baselines/reference/callConstructAssignment.js b/tests/baselines/reference/callConstructAssignment.js index 9f011c8ec02e8..3266df5314b6b 100644 --- a/tests/baselines/reference/callConstructAssignment.js +++ b/tests/baselines/reference/callConstructAssignment.js @@ -1,6 +1,4 @@ //// [callConstructAssignment.ts] - - var foo:{ ( ):void; } var bar:{ new ( ):any; } diff --git a/tests/baselines/reference/callOverloads2.errors.txt b/tests/baselines/reference/callOverloads2.errors.txt index 6291fa8f3de84..d49dc144157d9 100644 --- a/tests/baselines/reference/callOverloads2.errors.txt +++ b/tests/baselines/reference/callOverloads2.errors.txt @@ -1,15 +1,13 @@ -tests/cases/compiler/callOverloads2.ts(3,7): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads2.ts(11,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads2.ts(13,10): error TS2389: Function implementation name must be 'Foo'. -tests/cases/compiler/callOverloads2.ts(13,10): error TS2393: Duplicate function implementation. -tests/cases/compiler/callOverloads2.ts(14,10): error TS2393: Duplicate function implementation. -tests/cases/compiler/callOverloads2.ts(16,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/callOverloads2.ts(24,1): error TS2348: Value of type 'typeof Foo' is not callable. Did you mean to include 'new'? +tests/cases/compiler/callOverloads2.ts(1,7): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads2.ts(9,10): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads2.ts(11,10): error TS2389: Function implementation name must be 'Foo'. +tests/cases/compiler/callOverloads2.ts(11,10): error TS2393: Duplicate function implementation. +tests/cases/compiler/callOverloads2.ts(12,10): error TS2393: Duplicate function implementation. +tests/cases/compiler/callOverloads2.ts(14,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/callOverloads2.ts(22,1): error TS2348: Value of type 'typeof Foo' is not callable. Did you mean to include 'new'? ==== tests/cases/compiler/callOverloads2.ts (7 errors) ==== - - class Foo { // error ~~~ !!! error TS2300: Duplicate identifier 'Foo'. diff --git a/tests/baselines/reference/callOverloads2.js b/tests/baselines/reference/callOverloads2.js index b890ee8bde967..9762a6e925f96 100644 --- a/tests/baselines/reference/callOverloads2.js +++ b/tests/baselines/reference/callOverloads2.js @@ -1,6 +1,4 @@ //// [callOverloads2.ts] - - class Foo { // error bar1() { /*WScript.Echo("bar1");*/ } diff --git a/tests/baselines/reference/callOverloads3.errors.txt b/tests/baselines/reference/callOverloads3.errors.txt index ecb889bc1ab7d..9b14a6791a3a4 100644 --- a/tests/baselines/reference/callOverloads3.errors.txt +++ b/tests/baselines/reference/callOverloads3.errors.txt @@ -1,14 +1,13 @@ +tests/cases/compiler/callOverloads3.ts(1,10): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads3.ts(1,16): error TS2304: Cannot find name 'Foo'. tests/cases/compiler/callOverloads3.ts(2,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads3.ts(2,16): error TS2304: Cannot find name 'Foo'. -tests/cases/compiler/callOverloads3.ts(3,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads3.ts(3,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/callOverloads3.ts(3,24): error TS2304: Cannot find name 'Foo'. -tests/cases/compiler/callOverloads3.ts(4,7): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads3.ts(12,10): error TS2350: Only a void function can be called with the 'new' keyword. +tests/cases/compiler/callOverloads3.ts(2,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/callOverloads3.ts(2,24): error TS2304: Cannot find name 'Foo'. +tests/cases/compiler/callOverloads3.ts(3,7): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads3.ts(11,10): error TS2350: Only a void function can be called with the 'new' keyword. ==== tests/cases/compiler/callOverloads3.ts (7 errors) ==== - function Foo():Foo; // error ~~~ !!! error TS2300: Duplicate identifier 'Foo'. diff --git a/tests/baselines/reference/callOverloads3.js b/tests/baselines/reference/callOverloads3.js index e5d678543c647..ecd6a39f5697b 100644 --- a/tests/baselines/reference/callOverloads3.js +++ b/tests/baselines/reference/callOverloads3.js @@ -1,5 +1,4 @@ //// [callOverloads3.ts] - function Foo():Foo; // error function Foo(s:string):Foo; // error class Foo { // error diff --git a/tests/baselines/reference/callOverloads4.errors.txt b/tests/baselines/reference/callOverloads4.errors.txt index 3010d7c15d8f7..04ac340c990f0 100644 --- a/tests/baselines/reference/callOverloads4.errors.txt +++ b/tests/baselines/reference/callOverloads4.errors.txt @@ -1,14 +1,13 @@ +tests/cases/compiler/callOverloads4.ts(1,10): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads4.ts(1,16): error TS2304: Cannot find name 'Foo'. tests/cases/compiler/callOverloads4.ts(2,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads4.ts(2,16): error TS2304: Cannot find name 'Foo'. -tests/cases/compiler/callOverloads4.ts(3,10): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads4.ts(3,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/callOverloads4.ts(3,24): error TS2304: Cannot find name 'Foo'. -tests/cases/compiler/callOverloads4.ts(4,7): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/callOverloads4.ts(12,10): error TS2350: Only a void function can be called with the 'new' keyword. +tests/cases/compiler/callOverloads4.ts(2,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/callOverloads4.ts(2,24): error TS2304: Cannot find name 'Foo'. +tests/cases/compiler/callOverloads4.ts(3,7): error TS2300: Duplicate identifier 'Foo'. +tests/cases/compiler/callOverloads4.ts(11,10): error TS2350: Only a void function can be called with the 'new' keyword. ==== tests/cases/compiler/callOverloads4.ts (7 errors) ==== - function Foo():Foo; // error ~~~ !!! error TS2300: Duplicate identifier 'Foo'. diff --git a/tests/baselines/reference/callOverloads4.js b/tests/baselines/reference/callOverloads4.js index dfb274dfb6e35..ea2bd8572eb3e 100644 --- a/tests/baselines/reference/callOverloads4.js +++ b/tests/baselines/reference/callOverloads4.js @@ -1,5 +1,4 @@ //// [callOverloads4.ts] - function Foo():Foo; // error function Foo(s:string):Foo; // error class Foo { // error diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js index caba9d7ef6eac..99fb3a17a6f5e 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js @@ -1,5 +1,4 @@ //// [callSignatureWithoutReturnTypeAnnotationInference.ts] - // Call signatures without a return type should infer one from the function body (if present) // Simple types diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols index dd302da36718e..cf2aef2b70246 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols @@ -1,56 +1,55 @@ === tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts === - // Call signatures without a return type should infer one from the function body (if present) // Simple types function foo(x) { >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 4, 13)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 3, 13)) return 1; } var r = foo(1); ->r : Symbol(r, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 3)) +>r : Symbol(r, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 3)) >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0)) function foo2(x) { ->foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14)) +>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 15)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 8, 14)) return foo(x); >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 8, 14)) } var r2 = foo2(1); ->r2 : Symbol(r2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 3)) ->foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15)) +>r2 : Symbol(r2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 3)) +>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 15)) function foo3() { ->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17)) +>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17)) return foo3(); ->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17)) +>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17)) } var r3 = foo3(); ->r3 : Symbol(r3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 3)) ->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17)) +>r3 : Symbol(r3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 3)) +>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17)) function foo4(x: T) { ->foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16)) ->T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17)) ->T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14)) +>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 16)) +>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 17)) +>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 14)) return x; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 17)) } var r4 = foo4(1); ->r4 : Symbol(r4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 3)) ->foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16)) +>r4 : Symbol(r4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 3)) +>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 16)) function foo5(x) { ->foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 24, 14)) +>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 23, 14)) if (true) { return 1; @@ -59,17 +58,17 @@ function foo5(x) { } } var r5 = foo5(1); ->r5 : Symbol(r5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 3)) ->foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17)) +>r5 : Symbol(r5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 3)) +>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 17)) function foo6(x) { ->foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 33, 14)) +>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 32, 14)) try { } catch (e) { ->e : Symbol(e, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 36, 11)) +>e : Symbol(e, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 35, 11)) return []; } @@ -78,179 +77,179 @@ function foo6(x) { } } var r6 = foo6(1); ->r6 : Symbol(r6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 3)) ->foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17)) +>r6 : Symbol(r6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 3)) +>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 17)) function foo7(x) { ->foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14)) +>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 44, 14)) return typeof x; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 44, 14)) } var r7 = foo7(1); ->r7 : Symbol(r7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 3)) ->foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17)) +>r7 : Symbol(r7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 3)) +>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 17)) // object types function foo8(x: number) { ->foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14)) +>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14)) return { x: x }; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 52, 12)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 12)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14)) } var r8 = foo8(1); ->r8 : Symbol(r8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 3)) ->foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17)) +>r8 : Symbol(r8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 3)) +>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 17)) interface I { ->I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17)) +>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 17)) foo: string; ->foo : Symbol(I.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 56, 13)) +>foo : Symbol(I.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 55, 13)) } function foo9(x: number) { ->foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 14)) +>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 57, 1)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 14)) var i: I; ->i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7)) ->I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17)) +>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 7)) +>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 17)) return i; ->i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7)) +>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 7)) } var r9 = foo9(1); ->r9 : Symbol(r9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 3)) ->foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1)) +>r9 : Symbol(r9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 3)) +>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 57, 1)) class C { ->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17)) +>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 17)) foo: string; ->foo : Symbol(C.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 65, 9)) +>foo : Symbol(C.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 64, 9)) } function foo10(x: number) { ->foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 15)) +>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 66, 1)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 15)) var c: C; ->c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7)) ->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17)) +>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 7)) +>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 17)) return c; ->c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7)) +>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 7)) } var r10 = foo10(1); ->r10 : Symbol(r10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 3)) ->foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1)) +>r10 : Symbol(r10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 3)) +>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 66, 1)) module M { ->M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19)) +>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 19)) export var x = 1; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 74, 14)) export class C { foo: string } ->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 21)) ->foo : Symbol(C.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 20)) +>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 74, 21)) +>foo : Symbol(C.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 20)) } function foo11() { ->foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1)) +>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 1)) return M; ->M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19)) +>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 19)) } var r11 = foo11(); ->r11 : Symbol(r11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 3)) ->foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1)) +>r11 : Symbol(r11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 3)) +>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 1)) // merged declarations interface I2 { ->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1)) +>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1)) x: number; ->x : Symbol(I2.x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 84, 14)) +>x : Symbol(I2.x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 83, 14)) } interface I2 { ->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1)) +>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1)) y: number; ->y : Symbol(I2.y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 87, 14)) +>y : Symbol(I2.y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 14)) } function foo12() { ->foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1)) +>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 88, 1)) var i2: I2; ->i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7)) ->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1)) +>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 90, 7)) +>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1)) return i2; ->i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7)) +>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 90, 7)) } var r12 = foo12(); ->r12 : Symbol(r12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 3)) ->foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1)) +>r12 : Symbol(r12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 3)) +>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 88, 1)) function m1() { return 1; } ->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27)) +>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27)) module m1 { export var y = 2; } ->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27)) ->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 22)) +>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27)) +>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 22)) function foo13() { ->foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31)) +>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 31)) return m1; ->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27)) +>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27)) } var r13 = foo13(); ->r13 : Symbol(r13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 3)) ->foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31)) +>r13 : Symbol(r13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 3)) +>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 31)) class c1 { ->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1)) +>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1)) foo: string; ->foo : Symbol(c1.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 103, 10)) +>foo : Symbol(c1.foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 102, 10)) constructor(x) { } ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 16)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 104, 16)) } module c1 { ->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1)) +>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1)) export var x = 1; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 107, 14)) } function foo14() { ->foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1)) +>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 1)) return c1; ->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1)) +>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1)) } var r14 = foo14(); ->r14 : Symbol(r14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 3)) ->foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1)) +>r14 : Symbol(r14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 3)) +>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 1)) enum e1 { A } ->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13)) ->A : Symbol(e1.A, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 9)) +>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13)) +>A : Symbol(e1.A, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 9)) module e1 { export var y = 1; } ->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13)) ->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 22)) +>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13)) +>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 22)) function foo15() { ->foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31)) +>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 31)) return e1; ->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13)) +>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13)) } var r15 = foo15(); ->r15 : Symbol(r15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 120, 3)) ->foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31)) +>r15 : Symbol(r15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 119, 3)) +>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 31)) diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types index 658eff38bbb8a..3b2d8f25d38a9 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts === - // Call signatures without a return type should infer one from the function body (if present) // Simple types diff --git a/tests/baselines/reference/callWithSpreadES6.js b/tests/baselines/reference/callWithSpreadES6.js index 11fa8d6edcdc5..9e7f244d41a5e 100644 --- a/tests/baselines/reference/callWithSpreadES6.js +++ b/tests/baselines/reference/callWithSpreadES6.js @@ -1,5 +1,4 @@ //// [callWithSpreadES6.ts] - interface X { foo(x: number, y: number, ...z: string[]); } diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols index 518b04162b25f..dd12cd818061c 100644 --- a/tests/baselines/reference/callWithSpreadES6.symbols +++ b/tests/baselines/reference/callWithSpreadES6.symbols @@ -1,160 +1,159 @@ === tests/cases/conformance/expressions/functionCalls/callWithSpreadES6.ts === - interface X { >X : Symbol(X, Decl(callWithSpreadES6.ts, 0, 0)) foo(x: number, y: number, ...z: string[]); ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 2, 8)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 2, 18)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 2, 29)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 1, 8)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 1, 18)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 1, 29)) } function foo(x: number, y: number, ...z: string[]) { ->foo : Symbol(foo, Decl(callWithSpreadES6.ts, 3, 1)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 5, 13)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 5, 23)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 5, 34)) +>foo : Symbol(foo, Decl(callWithSpreadES6.ts, 2, 1)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 4, 13)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 4, 23)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 4, 34)) } var a: string[]; ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) var z: number[]; ->z : Symbol(z, Decl(callWithSpreadES6.ts, 9, 3)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 8, 3)) var obj: X; ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) >X : Symbol(X, Decl(callWithSpreadES6.ts, 0, 0)) var xa: X[]; ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) >X : Symbol(X, Decl(callWithSpreadES6.ts, 0, 0)) foo(1, 2, "abc"); ->foo : Symbol(foo, Decl(callWithSpreadES6.ts, 3, 1)) +>foo : Symbol(foo, Decl(callWithSpreadES6.ts, 2, 1)) foo(1, 2, ...a); ->foo : Symbol(foo, Decl(callWithSpreadES6.ts, 3, 1)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>foo : Symbol(foo, Decl(callWithSpreadES6.ts, 2, 1)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) foo(1, 2, ...a, "abc"); ->foo : Symbol(foo, Decl(callWithSpreadES6.ts, 3, 1)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>foo : Symbol(foo, Decl(callWithSpreadES6.ts, 2, 1)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) obj.foo(1, 2, "abc"); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) obj.foo(1, 2, ...a); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) obj.foo(1, 2, ...a, "abc"); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) (obj.foo)(1, 2, "abc"); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) (obj.foo)(1, 2, ...a); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) (obj.foo)(1, 2, ...a, "abc"); ->obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->obj : Symbol(obj, Decl(callWithSpreadES6.ts, 10, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) xa[1].foo(1, 2, "abc"); ->xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) +>xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) xa[1].foo(1, 2, ...a); ->xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) xa[1].foo(1, 2, ...a, "abc"); ->xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) (xa[1].foo)(...[1, 2, "abc"]); >Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) ->xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) ->foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) +>xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) +>xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3)) +>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13)) class C { ->C : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) +>C : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) constructor(x: number, y: number, ...z: string[]) { ->x : Symbol(x, Decl(callWithSpreadES6.ts, 32, 16)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 32, 26)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 32, 37)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 31, 16)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 31, 26)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 31, 37)) this.foo(x, y); ->this.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->this : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 32, 16)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 32, 26)) +>this.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>this : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 31, 16)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 31, 26)) this.foo(x, y, ...z); ->this.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->this : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 32, 16)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 32, 26)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 32, 37)) +>this.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>this : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 31, 16)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 31, 26)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 31, 37)) } foo(x: number, y: number, ...z: string[]) { ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->x : Symbol(x, Decl(callWithSpreadES6.ts, 36, 8)) ->y : Symbol(y, Decl(callWithSpreadES6.ts, 36, 18)) ->z : Symbol(z, Decl(callWithSpreadES6.ts, 36, 29)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>x : Symbol(x, Decl(callWithSpreadES6.ts, 35, 8)) +>y : Symbol(y, Decl(callWithSpreadES6.ts, 35, 18)) +>z : Symbol(z, Decl(callWithSpreadES6.ts, 35, 29)) } } class D extends C { ->D : Symbol(D, Decl(callWithSpreadES6.ts, 38, 1)) ->C : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) +>D : Symbol(D, Decl(callWithSpreadES6.ts, 37, 1)) +>C : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) constructor() { super(1, 2); ->super : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) +>super : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) super(1, 2, ...a); ->super : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>super : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) } foo() { ->foo : Symbol(D.foo, Decl(callWithSpreadES6.ts, 44, 5)) +>foo : Symbol(D.foo, Decl(callWithSpreadES6.ts, 43, 5)) super.foo(1, 2); ->super.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->super : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) +>super.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>super : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) super.foo(1, 2, ...a); ->super.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->super : Symbol(C, Decl(callWithSpreadES6.ts, 29, 40)) ->foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 35, 5)) ->a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) +>super.foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>super : Symbol(C, Decl(callWithSpreadES6.ts, 28, 40)) +>foo : Symbol(C.foo, Decl(callWithSpreadES6.ts, 34, 5)) +>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3)) } } diff --git a/tests/baselines/reference/callWithSpreadES6.types b/tests/baselines/reference/callWithSpreadES6.types index b25b8dc02b543..4ce4bb2a75cc6 100644 --- a/tests/baselines/reference/callWithSpreadES6.types +++ b/tests/baselines/reference/callWithSpreadES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/functionCalls/callWithSpreadES6.ts === - interface X { >X : X diff --git a/tests/baselines/reference/capturedLetConstInLoop2.js b/tests/baselines/reference/capturedLetConstInLoop2.js index e4461760af355..94bc8669cf593 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2.js +++ b/tests/baselines/reference/capturedLetConstInLoop2.js @@ -1,6 +1,4 @@ //// [capturedLetConstInLoop2.ts] - - // ========let function foo0(x) { for (let x of []) { diff --git a/tests/baselines/reference/capturedLetConstInLoop2.symbols b/tests/baselines/reference/capturedLetConstInLoop2.symbols index 8fb2de72999a6..d0a174e778271 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop2.symbols @@ -1,519 +1,517 @@ === tests/cases/compiler/capturedLetConstInLoop2.ts === - - // ========let function foo0(x) { >foo0 : Symbol(foo0, Decl(capturedLetConstInLoop2.ts, 0, 0)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 3, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 1, 14)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 4, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 2, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 5, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 3, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 4, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 2, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 3, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 4, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 2, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 3, 11)) } } function foo0_1(x) { ->foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2.ts, 9, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 11, 16)) +>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2.ts, 7, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 9, 16)) for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 12, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 10, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 13, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 11, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 12, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 13, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 10, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 11, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 12, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 13, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 10, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 11, 11)) } } function foo1(x) { ->foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2.ts, 17, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 19, 14)) +>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2.ts, 15, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 17, 14)) for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 21, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 19, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 21, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 19, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 21, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 18, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 19, 11)) } } function foo2(x) { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2.ts, 25, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 27, 14)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2.ts, 23, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 25, 14)) while (1 === 1) { let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 29, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 27, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 27, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 29, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 25, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 27, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 27, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 29, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 25, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 27, 11)) } } function foo3(x) { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2.ts, 33, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 35, 14)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2.ts, 31, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 33, 14)) do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 37, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 35, 11)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 38, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 36, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 37, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 38, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 35, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 36, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 37, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 38, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 35, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 36, 11)) } while (1 === 1) } function foo4(x) { ->foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2.ts, 42, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 44, 14)) +>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2.ts, 40, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 42, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 45, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 45, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 45, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 43, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 43, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 43, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 46, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 44, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 47, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 45, 11)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 47, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 44, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 47, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 44, 11)) } } function foo5(x) { ->foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2.ts, 51, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 53, 14)) +>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2.ts, 49, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 51, 14)) for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 54, 19)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 52, 19)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 55, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 53, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 54, 19)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 55, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 52, 19)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 53, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 54, 19)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 55, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 52, 19)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 53, 11)) } } function foo6(x) { ->foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2.ts, 59, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 62, 14)) +>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2.ts, 57, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 60, 14)) while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 64, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 64, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 62, 14)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 65, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 63, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 64, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 64, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 65, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 62, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 63, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 64, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 64, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 65, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 62, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 63, 11)) } } function foo7(x) { ->foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2.ts, 69, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 71, 14)) +>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2.ts, 67, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 69, 14)) do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 73, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 73, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 71, 14)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 74, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 72, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 73, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 73, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 74, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 71, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 72, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 73, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 73, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 74, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 71, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 72, 11)) } while (1 === 1) } function foo8(x) { ->foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2.ts, 78, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 81, 14)) +>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2.ts, 76, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 79, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 83, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 81, 11)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 84, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 82, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 83, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 84, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 81, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 82, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 83, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 84, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 81, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 80, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 82, 11)) } } ///=======const function foo0_c(x) { ->foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2.ts, 88, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 90, 16)) +>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2.ts, 86, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 88, 16)) for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 91, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 89, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 92, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 90, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 91, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 92, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 89, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 90, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 91, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 92, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 89, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 90, 13)) } } function foo0_1_c(x) { ->foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2.ts, 96, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 98, 18)) +>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2.ts, 94, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 96, 18)) for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 99, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 97, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 100, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 98, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 99, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 100, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 97, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 98, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 99, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 100, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 97, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 98, 13)) } } function foo1_c(x) { ->foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2.ts, 104, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 106, 16)) +>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2.ts, 102, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 104, 16)) for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 105, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 105, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 108, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 106, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 108, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 105, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 106, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 108, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 105, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 106, 13)) } } function foo2_c(x) { ->foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2.ts, 112, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 114, 16)) +>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2.ts, 110, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 112, 16)) while (1 === 1) { const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 116, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 114, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 114, 16)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 116, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 112, 16)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 114, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 114, 16)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 116, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 112, 16)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 114, 13)) } } function foo3_c(x) { ->foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2.ts, 120, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 122, 16)) +>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2.ts, 118, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 120, 16)) do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 124, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 122, 13)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 125, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 123, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 124, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 125, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 122, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 123, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 124, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 125, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 122, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 123, 13)) } while (1 === 1) } function foo4_c(x) { ->foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2.ts, 129, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 131, 16)) +>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2.ts, 127, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 129, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 132, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 132, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 130, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 130, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 133, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 131, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 134, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 132, 13)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 134, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 133, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 131, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 134, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 133, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 131, 13)) } } function foo5_c(x) { ->foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2.ts, 138, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 140, 16)) +>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2.ts, 136, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 138, 16)) for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 141, 21)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 139, 21)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 139, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 142, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 140, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 141, 21)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 142, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 139, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 140, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 141, 21)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 142, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 139, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 140, 13)) } } function foo6_c(x) { ->foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2.ts, 146, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 149, 16)) +>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2.ts, 144, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 147, 16)) while (1 === 1) { const x = 1, y =1 ; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 151, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 151, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 149, 20)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 152, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 150, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 151, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 151, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 152, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 149, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 150, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 151, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 151, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 152, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 149, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 150, 13)) } } function foo7_c(x) { ->foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2.ts, 156, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 158, 16)) +>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2.ts, 154, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 156, 16)) do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 160, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 160, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 158, 20)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 161, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 159, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 160, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 160, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 161, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 158, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 159, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 160, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 160, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 161, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 158, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 159, 13)) } while (1 === 1) } function foo8_c(x) { ->foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2.ts, 165, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 168, 16)) +>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2.ts, 163, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 166, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 167, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 167, 14)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 170, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 168, 13)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 171, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 169, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 170, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 171, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 168, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 167, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 169, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 170, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 171, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 168, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 167, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 169, 13)) } } diff --git a/tests/baselines/reference/capturedLetConstInLoop2.types b/tests/baselines/reference/capturedLetConstInLoop2.types index 4f819d3c3f998..be90b52b334da 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2.types +++ b/tests/baselines/reference/capturedLetConstInLoop2.types @@ -1,6 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop2.ts === - - // ========let function foo0(x) { >foo0 : (x: any) => void diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.js b/tests/baselines/reference/capturedLetConstInLoop2_ES6.js index aac040d4d29b1..59bd81b5a4de7 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop2_ES6.ts] - // ========let function foo0(x) { for (let x of []) { diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols index 0dd74bc4b25db..ff1054c2b213a 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols @@ -1,518 +1,517 @@ === tests/cases/compiler/capturedLetConstInLoop2_ES6.ts === - // ========let function foo0(x) { >foo0 : Symbol(foo0, Decl(capturedLetConstInLoop2_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 1, 14)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 3, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 4, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 3, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 3, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 4, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 3, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 3, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 4, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 3, 11)) } } function foo0_1(x) { ->foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2_ES6.ts, 8, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 16)) +>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2_ES6.ts, 7, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 9, 16)) for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 11, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 12, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 11, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 11, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 12, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 11, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 11, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 12, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 11, 11)) } } function foo1(x) { ->foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2_ES6.ts, 16, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 14)) +>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2_ES6.ts, 15, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 17, 14)) for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 20, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 19, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 20, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 19, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 20, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 19, 11)) } } function foo2(x) { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2_ES6.ts, 24, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 26, 14)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2_ES6.ts, 23, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 25, 14)) while (1 === 1) { let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 28, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 27, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 26, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 28, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 25, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 27, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 26, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 28, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 25, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 27, 11)) } } function foo3(x) { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2_ES6.ts, 32, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 34, 14)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2_ES6.ts, 31, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 33, 14)) do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 35, 11)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 37, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 37, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 35, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 37, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 35, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11)) } while (1 === 1) } function foo4(x) { ->foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2_ES6.ts, 41, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 43, 14)) +>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2_ES6.ts, 40, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 42, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 44, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 44, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 44, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 43, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 43, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 43, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 44, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 46, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 44, 11)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 46, 11)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 44, 11)) } } function foo5(x) { ->foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2_ES6.ts, 50, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 14)) +>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2_ES6.ts, 49, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 51, 14)) for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 53, 19)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 52, 19)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 54, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 53, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 53, 19)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 54, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 52, 19)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 53, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 53, 19)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 54, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 52, 19)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 53, 11)) } } function foo6(x) { ->foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2_ES6.ts, 58, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 61, 14)) +>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2_ES6.ts, 57, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 60, 14)) while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 63, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 62, 14)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 64, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 63, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 64, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 62, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 63, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 64, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 62, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 62, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11)) } } function foo7(x) { ->foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2_ES6.ts, 68, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 70, 14)) +>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2_ES6.ts, 67, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 69, 14)) do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 72, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 71, 14)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 73, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 72, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 73, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 71, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 72, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 73, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 71, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 71, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11)) } while (1 === 1) } function foo8(x) { ->foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2_ES6.ts, 77, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 80, 14)) +>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2_ES6.ts, 76, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 79, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 81, 11)) let a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 83, 11)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 83, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 81, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 83, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 81, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 80, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11)) } } ///=======const function foo0_c(x) { ->foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2_ES6.ts, 87, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 16)) +>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2_ES6.ts, 86, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 88, 16)) for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 90, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 91, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 90, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 90, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 91, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 90, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 90, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 91, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 90, 13)) } } function foo0_1_c(x) { ->foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2_ES6.ts, 95, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 18)) +>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2_ES6.ts, 94, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 96, 18)) for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 98, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 99, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 98, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 98, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 99, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 98, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 98, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 99, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 98, 13)) } } function foo1_c(x) { ->foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2_ES6.ts, 103, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 16)) +>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2_ES6.ts, 102, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 104, 16)) for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 107, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 106, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 107, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 106, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 107, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 106, 13)) } } function foo2_c(x) { ->foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2_ES6.ts, 111, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 113, 16)) +>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2_ES6.ts, 110, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 112, 16)) while (1 === 1) { const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 115, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 114, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 113, 16)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 115, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 112, 16)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 114, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 113, 16)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 115, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 112, 16)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 114, 13)) } } function foo3_c(x) { ->foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2_ES6.ts, 119, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 121, 16)) +>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2_ES6.ts, 118, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 120, 16)) do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 122, 13)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 124, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 124, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 122, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 124, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 122, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13)) } while (1 === 1) } function foo4_c(x) { ->foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2_ES6.ts, 128, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 130, 16)) +>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2_ES6.ts, 127, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 129, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 131, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 131, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 130, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 130, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 131, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 133, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) (function() { return x + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 133, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 131, 13)) (() => x + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 133, 13)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 131, 13)) } } function foo5_c(x) { ->foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2_ES6.ts, 137, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 16)) +>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2_ES6.ts, 136, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 138, 16)) for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 140, 21)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 139, 21)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 14)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 141, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 140, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 140, 21)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 141, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 139, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 140, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 140, 21)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 141, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 139, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 140, 13)) } } function foo6_c(x) { ->foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2_ES6.ts, 145, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 148, 16)) +>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2_ES6.ts, 144, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 147, 16)) while (1 === 1) { const x = 1, y =1 ; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 150, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 149, 20)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 151, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 150, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 151, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 149, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 150, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 151, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 149, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 149, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13)) } } function foo7_c(x) { ->foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2_ES6.ts, 155, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 157, 16)) +>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2_ES6.ts, 154, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 156, 16)) do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 159, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 158, 20)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 160, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 159, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 160, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 158, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 159, 20)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 160, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 158, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 158, 20)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13)) } while (1 === 1) } function foo8_c(x) { ->foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2_ES6.ts, 164, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 167, 16)) +>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2_ES6.ts, 163, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 166, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 167, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 167, 14)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 168, 13)) const a = arguments.length; ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 170, 13)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return x + y + a }); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 170, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 168, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 167, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) (() => x + y + a); ->x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14)) ->a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 170, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 168, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 167, 14)) +>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13)) } } diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.types b/tests/baselines/reference/capturedLetConstInLoop2_ES6.types index e72221d85cd84..fb1779237ef63 100644 --- a/tests/baselines/reference/capturedLetConstInLoop2_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop2_ES6.ts === - // ========let function foo0(x) { >foo0 : (x: any) => void diff --git a/tests/baselines/reference/capturedLetConstInLoop3_ES6.js b/tests/baselines/reference/capturedLetConstInLoop3_ES6.js index f27713a52a889..367db066edd43 100644 --- a/tests/baselines/reference/capturedLetConstInLoop3_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop3_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop3_ES6.ts] - ///=========let declare function use(a: any); function foo0(x) { diff --git a/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols index b07a724cbbe32..7ec20d74e6d10 100644 --- a/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols @@ -1,566 +1,565 @@ === tests/cases/compiler/capturedLetConstInLoop3_ES6.ts === - ///=========let declare function use(a: any); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->a : Symbol(a, Decl(capturedLetConstInLoop3_ES6.ts, 2, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop3_ES6.ts, 1, 21)) function foo0(x) { ->foo0 : Symbol(foo0, Decl(capturedLetConstInLoop3_ES6.ts, 2, 29)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 14)) +>foo0 : Symbol(foo0, Decl(capturedLetConstInLoop3_ES6.ts, 1, 29)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 2, 14)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 4, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 12)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 4, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 4, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 4, 11)) } function foo0_1(x) { ->foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop3_ES6.ts, 11, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 16)) +>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop3_ES6.ts, 10, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 12, 16)) for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 14, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 12)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 14, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 14, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 14, 11)) } function foo1(x) { ->foo1 : Symbol(foo1, Decl(capturedLetConstInLoop3_ES6.ts, 21, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 14)) +>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop3_ES6.ts, 20, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 22, 14)) for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 24, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 24, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 24, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 24, 11)) } function foo2(x) { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop3_ES6.ts, 31, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 33, 14)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop3_ES6.ts, 30, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 32, 14)) while (1 === 1) { let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 34, 11)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 34, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 34, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 34, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11)) } function foo3(x) { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop3_ES6.ts, 42, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 44, 14)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop3_ES6.ts, 41, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 43, 14)) do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 45, 11)) var v; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 45, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 45, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) } while (1 === 1); use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11)) } function foo4(x) { ->foo4 : Symbol(foo4, Decl(capturedLetConstInLoop3_ES6.ts, 53, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 55, 14)) +>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop3_ES6.ts, 52, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 54, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 55, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 55, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 55, 12)) var v = y; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 56, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 55, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 58, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 58, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 56, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 58, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 56, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 56, 11)) } function foo5(x) { ->foo5 : Symbol(foo5, Decl(capturedLetConstInLoop3_ES6.ts, 64, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 14)) +>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop3_ES6.ts, 63, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 65, 14)) for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 67, 19)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 66, 19)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 67, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 67, 19)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 66, 19)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 67, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 67, 19)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 66, 19)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 67, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 67, 11)) } function foo6(x) { ->foo6 : Symbol(foo6, Decl(capturedLetConstInLoop3_ES6.ts, 74, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 77, 14)) +>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop3_ES6.ts, 73, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 76, 14)) while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 79, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 78, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 78, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 78, 11)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 79, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 78, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 78, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 79, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 78, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 78, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) } use(v) >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11)) } function foo7(x) { ->foo7 : Symbol(foo7, Decl(capturedLetConstInLoop3_ES6.ts, 86, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 88, 14)) +>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop3_ES6.ts, 85, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 87, 14)) do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 90, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 89, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 89, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 89, 11)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 90, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 89, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 89, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 90, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 89, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 89, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) } while (1 === 1); use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11)) } function foo8(x) { ->foo8 : Symbol(foo8, Decl(capturedLetConstInLoop3_ES6.ts, 97, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 100, 14)) +>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop3_ES6.ts, 96, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 99, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 101, 11)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 101, 11)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 101, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 101, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 100, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11)) } //===const function foo0_c(x) { ->foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop3_ES6.ts, 109, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 16)) +>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop3_ES6.ts, 108, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 110, 16)) for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 112, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 14)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 112, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 112, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 112, 11)) } function foo0_1_c(x) { ->foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop3_ES6.ts, 119, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 18)) +>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop3_ES6.ts, 118, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 120, 18)) for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 122, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 14)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 122, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 122, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 122, 11)) } function foo1_c(x) { ->foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop3_ES6.ts, 129, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 16)) +>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop3_ES6.ts, 128, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 130, 16)) for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 132, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 132, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 132, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 132, 11)) } function foo2_c(x) { ->foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop3_ES6.ts, 139, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 141, 16)) +>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop3_ES6.ts, 138, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 140, 16)) while (1 === 1) { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 142, 13)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 143, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 142, 13)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 142, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 143, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 142, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 143, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 143, 11)) } function foo3_c(x) { ->foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop3_ES6.ts, 150, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 152, 16)) +>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop3_ES6.ts, 149, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 151, 16)) do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 154, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 153, 13)) var v; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 154, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 154, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 153, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 154, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 154, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 153, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 154, 11)) } while (1 === 1); use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 154, 11)) } function foo4_c(x) { ->foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop3_ES6.ts, 161, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 163, 16)) +>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop3_ES6.ts, 160, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 162, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 164, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 164, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 163, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 163, 14)) var v = y; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 164, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 164, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 163, 14)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 166, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 165, 13)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 166, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 165, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 164, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 166, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 165, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 164, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 164, 11)) } function foo5_c(x) { ->foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop3_ES6.ts, 172, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 16)) +>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop3_ES6.ts, 171, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 173, 16)) for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 175, 21)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 174, 21)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 175, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 175, 21)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 174, 21)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 175, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 175, 21)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 174, 21)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 175, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 175, 11)) } function foo6_c(x) { ->foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop3_ES6.ts, 182, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 185, 16)) +>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop3_ES6.ts, 181, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 184, 16)) while (1 === 1) { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 187, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 186, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 186, 20)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 187, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 186, 13)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 187, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 186, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 186, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 187, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 187, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 186, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 186, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 187, 11)) } use(v) >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 187, 11)) } function foo7_c(x) { ->foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop3_ES6.ts, 194, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 196, 16)) +>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop3_ES6.ts, 193, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 195, 16)) do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 198, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 197, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 197, 20)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 198, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 197, 13)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 198, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 197, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 197, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 198, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 198, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 197, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 197, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 198, 11)) } while (1 === 1); use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 198, 11)) } function foo8_c(x) { ->foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop3_ES6.ts, 205, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 208, 16)) +>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop3_ES6.ts, 204, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 207, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 208, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 208, 14)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 209, 13)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 210, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 209, 13)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 209, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 208, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 210, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 209, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 208, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 210, 11)) } use(v); >use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 210, 11)) } diff --git a/tests/baselines/reference/capturedLetConstInLoop3_ES6.types b/tests/baselines/reference/capturedLetConstInLoop3_ES6.types index 9c11ae625744c..5a8d77c252cd5 100644 --- a/tests/baselines/reference/capturedLetConstInLoop3_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop3_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop3_ES6.ts === - ///=========let declare function use(a: any); >use : (a: any) => any diff --git a/tests/baselines/reference/capturedLetConstInLoop4.js b/tests/baselines/reference/capturedLetConstInLoop4.js index 2cade08f0a6d6..bc259a73a8838 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4.js +++ b/tests/baselines/reference/capturedLetConstInLoop4.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop4.ts] - //======let export function exportedFoo() { return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; diff --git a/tests/baselines/reference/capturedLetConstInLoop4.symbols b/tests/baselines/reference/capturedLetConstInLoop4.symbols index 19e78bbf2b43b..6554a5a9686b4 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop4.symbols @@ -1,394 +1,393 @@ === tests/cases/compiler/capturedLetConstInLoop4.ts === - //======let export function exportedFoo() { >exportedFoo : Symbol(exportedFoo, Decl(capturedLetConstInLoop4.ts, 0, 0)) return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 7, 7)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7)) ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 19, 7)) ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 26, 7)) ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 33, 7)) ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 40, 7)) ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 46, 7)) ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 53, 7)) ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 60, 7)) ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 67, 7)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 6, 7)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 12, 7)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 18, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 45, 7)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 52, 7)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 59, 7)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 66, 7)) } for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 5, 8)) var v0 = x; ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 7, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 6, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 5, 8)) (function() { return x + v0}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8)) ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 7, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 5, 8)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 6, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 5, 8)) } for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 11, 8)) var v00 = x; ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 12, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 11, 8)) (function() { return x + v00}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 11, 8)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 12, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 11, 8)) } for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) var v1 = x; ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 19, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 18, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) (function() { return x + v1}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 19, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 18, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 17, 8)) } while (1 === 1) { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 24, 7)) var v2 = x; ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 26, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 24, 7)) (function() { return x + v2}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7)) ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 26, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 24, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 25, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 24, 7)) } do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 31, 7)) var v3 = x; ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 33, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 31, 7)) (function() { return x + v3}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7)) ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 33, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 31, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 32, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 31, 7)) } while (1 === 1) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 38, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 38, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 38, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 37, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 37, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 37, 8)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 38, 7)) var v4 = x; ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 40, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 38, 7)) (function() { return x + v4}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7)) ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 40, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 38, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 39, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 38, 7)) } for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 45, 15)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 44, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) var v5 = x; ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 46, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 45, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) (function() { return x + y + v5}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 45, 15)) ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 46, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 44, 15)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 45, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 45, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 44, 15)) } while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 52, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 51, 10)) var v6 = x; ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 53, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 52, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 51, 7)) (function() { return x + y + v6}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 52, 10)) ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 53, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 51, 10)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 52, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 52, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 51, 10)) } do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 59, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 58, 10)) var v7 = x; ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 60, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 59, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 58, 7)) (function() { return x + y + v7}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 59, 10)) ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 60, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 58, 10)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 59, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 59, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 58, 10)) } while (1 === 1) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 65, 7)) var v8 = x; ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 67, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 66, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 65, 7)) (function() { return x + y + v8}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 67, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 65, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 66, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 65, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 64, 8)) } //======const export function exportedFoo2() { ->exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4.ts, 70, 1)) +>exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4.ts, 69, 1)) return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c; ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 78, 7)) ->v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 84, 7)) ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 90, 7)) ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 97, 7)) ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 104, 7)) ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 111, 7)) ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 117, 7)) ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 124, 7)) ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 131, 7)) ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 138, 7)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 77, 7)) +>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 83, 7)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 89, 7)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 96, 7)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 103, 7)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 110, 7)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 116, 7)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 123, 7)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 130, 7)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 137, 7)) } for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 76, 10)) var v0_c = x; ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 78, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 77, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 76, 10)) (function() { return x + v0_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10)) ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 78, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 76, 10)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 77, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 76, 10)) } for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 82, 10)) var v00_c = x; ->v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 84, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10)) +>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 83, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 82, 10)) (function() { return x + v00}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 82, 10)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 12, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 82, 10)) } for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) var v1_c = x; ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 90, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 89, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) (function() { return x + v1_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 90, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 89, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 88, 10)) } while (1 === 1) { const x =1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 95, 9)) var v2_c = x; ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 97, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 96, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 95, 9)) (function() { return x + v2_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9)) ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 97, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 95, 9)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 96, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 95, 9)) } do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 102, 9)) var v3_c = x; ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 104, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 103, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 102, 9)) (function() { return x + v3_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9)) ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 104, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 102, 9)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 103, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 102, 9)) } while (1 === 1) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 109, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 109, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 108, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 108, 10)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 109, 9)) var v4_c = x; ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 111, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 110, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 109, 9)) (function() { return x + v4_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9)) ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 111, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 109, 9)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 110, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 109, 9)) } for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 116, 17)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 115, 17)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) var v5_c = x; ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 117, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 116, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) (function() { return x + y + v5_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 116, 17)) ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 117, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 115, 17)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 116, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 116, 17)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 115, 17)) } while (1 === 1) { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 123, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 122, 16)) var v6_c = x; ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 124, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 123, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 122, 9)) (function() { return x + y + v6_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 123, 16)) ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 124, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 122, 16)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 123, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 123, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 122, 16)) } do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 130, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 129, 16)) var v7_c = x; ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 131, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 130, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 129, 9)) (function() { return x + y + v7_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 130, 16)) ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 131, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 129, 16)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 130, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 130, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 129, 16)) } while (1 === 1) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 135, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 135, 10)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 136, 9)) var v8_c = x; ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 138, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 137, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 136, 9)) (function() { return x + y + v8_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10)) ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 138, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 136, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 135, 10)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 137, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 136, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 135, 10)) } diff --git a/tests/baselines/reference/capturedLetConstInLoop4.types b/tests/baselines/reference/capturedLetConstInLoop4.types index 2c48463adec70..2fcff7625a179 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4.types +++ b/tests/baselines/reference/capturedLetConstInLoop4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop4.ts === - //======let export function exportedFoo() { >exportedFoo : () => string diff --git a/tests/baselines/reference/capturedLetConstInLoop4_ES6.js b/tests/baselines/reference/capturedLetConstInLoop4_ES6.js index 83b0af1f23c63..b1b60535475e9 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop4_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop4_ES6.ts] - //======let export function exportedFoo() { return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; @@ -145,6 +144,7 @@ for (const y = 0; y < 1;) { //// [capturedLetConstInLoop4_ES6.js] //======let +//======let export function exportedFoo() { return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; } diff --git a/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols index cc5a2ad54bcd8..df72686e7bee4 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols @@ -1,394 +1,393 @@ === tests/cases/compiler/capturedLetConstInLoop4_ES6.ts === - //======let export function exportedFoo() { >exportedFoo : Symbol(exportedFoo, Decl(capturedLetConstInLoop4_ES6.ts, 0, 0)) return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 7, 7)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7)) ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 19, 7)) ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 26, 7)) ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 33, 7)) ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 40, 7)) ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 46, 7)) ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 53, 7)) ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 60, 7)) ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 67, 7)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 6, 7)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 12, 7)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 18, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 45, 7)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) } for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 5, 8)) var v0 = x; ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 7, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 6, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 5, 8)) (function() { return x + v0}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8)) ->v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 7, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 5, 8)) +>v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 6, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 5, 8)) } for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 11, 8)) var v00 = x; ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 12, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 11, 8)) (function() { return x + v00}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 11, 8)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 12, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 11, 8)) } for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) var v1 = x; ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 19, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 18, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) (function() { return x + v1}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) ->v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 19, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) +>v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 18, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 17, 8)) } while (1 === 1) { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 24, 7)) var v2 = x; ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 26, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 24, 7)) (function() { return x + v2}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) ->v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 26, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 24, 7)) +>v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 24, 7)) } do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 31, 7)) var v3 = x; ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 33, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 31, 7)) (function() { return x + v3}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) ->v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 33, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 31, 7)) +>v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 31, 7)) } while (1 === 1) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 38, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 38, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 38, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 37, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 37, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 37, 8)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 38, 7)) var v4 = x; ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 40, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 38, 7)) (function() { return x + v4}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) ->v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 40, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 38, 7)) +>v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 38, 7)) } for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 45, 15)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 44, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) var v5 = x; ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 46, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 45, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) (function() { return x + y + v5}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 45, 15)) ->v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 46, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 44, 15)) +>v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 45, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 45, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 44, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 44, 15)) } while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 52, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 51, 10)) var v6 = x; ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 53, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 51, 7)) (function() { return x + y + v6}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 52, 10)) ->v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 53, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 51, 10)) +>v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 52, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 51, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 51, 10)) } do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 59, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 58, 10)) var v7 = x; ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 60, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 58, 7)) (function() { return x + y + v7}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 59, 10)) ->v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 60, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 58, 10)) +>v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 59, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 58, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 58, 10)) } while (1 === 1) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 65, 7)) var v8 = x; ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 67, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 65, 7)) (function() { return x + y + v8}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) ->v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 67, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 65, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) +>v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 65, 7)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 64, 8)) } //======const export function exportedFoo2() { ->exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4_ES6.ts, 70, 1)) +>exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4_ES6.ts, 69, 1)) return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c; ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 78, 7)) ->v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 84, 7)) ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 90, 7)) ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 97, 7)) ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 104, 7)) ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 111, 7)) ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 117, 7)) ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 124, 7)) ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 131, 7)) ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 138, 7)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 77, 7)) +>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 83, 7)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 89, 7)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 96, 7)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 103, 7)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 110, 7)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 116, 7)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 123, 7)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 130, 7)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 137, 7)) } for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 76, 10)) var v0_c = x; ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 78, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 77, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 76, 10)) (function() { return x + v0_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10)) ->v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 78, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 76, 10)) +>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 77, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 76, 10)) } for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 82, 10)) var v00_c = x; ->v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 84, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10)) +>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 83, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 82, 10)) (function() { return x + v00}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10)) ->v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 82, 10)) +>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 12, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 82, 10)) } for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) var v1_c = x; ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 90, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 89, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) (function() { return x + v1_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) ->v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 90, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) +>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 89, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 88, 10)) } while (1 === 1) { const x =1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 95, 9)) var v2_c = x; ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 97, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 96, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 95, 9)) (function() { return x + v2_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9)) ->v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 97, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 95, 9)) +>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 96, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 95, 9)) } do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 102, 9)) var v3_c = x; ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 104, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 103, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 102, 9)) (function() { return x + v3_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9)) ->v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 104, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 102, 9)) +>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 103, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 102, 9)) } while (1 === 1) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 109, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 109, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 108, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 108, 10)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 109, 9)) var v4_c = x; ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 111, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 110, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 109, 9)) (function() { return x + v4_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9)) ->v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 111, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 109, 9)) +>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 110, 7)) (() => x); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 109, 9)) } for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 116, 17)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 115, 17)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) var v5_c = x; ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 117, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 116, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) (function() { return x + y + v5_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 116, 17)) ->v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 117, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 115, 17)) +>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 116, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 116, 17)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 115, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 115, 17)) } while (1 === 1) { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 123, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 122, 16)) var v6_c = x; ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 124, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 123, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 122, 9)) (function() { return x + y + v6_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 123, 16)) ->v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 124, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 122, 16)) +>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 123, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 123, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 122, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 122, 16)) } do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 130, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 129, 16)) var v7_c = x; ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 131, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 130, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 129, 9)) (function() { return x + y + v7_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 130, 16)) ->v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 131, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 129, 16)) +>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 130, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 130, 16)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 129, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 129, 16)) } while (1 === 1) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 135, 10)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 135, 10)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 136, 9)) var v8_c = x; ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 138, 7)) ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 137, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 136, 9)) (function() { return x + y + v8_c}); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10)) ->v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 138, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 136, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 135, 10)) +>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 137, 7)) (() => x + y); ->x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9)) ->y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10)) +>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 136, 9)) +>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 135, 10)) } diff --git a/tests/baselines/reference/capturedLetConstInLoop4_ES6.types b/tests/baselines/reference/capturedLetConstInLoop4_ES6.types index 32af60f24e4f8..546cdd93b4365 100644 --- a/tests/baselines/reference/capturedLetConstInLoop4_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop4_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop4_ES6.ts === - //======let export function exportedFoo() { >exportedFoo : () => string diff --git a/tests/baselines/reference/capturedLetConstInLoop5_ES6.errors.txt b/tests/baselines/reference/capturedLetConstInLoop5_ES6.errors.txt index a9a4742631ac5..1826ffa99f734 100644 --- a/tests/baselines/reference/capturedLetConstInLoop5_ES6.errors.txt +++ b/tests/baselines/reference/capturedLetConstInLoop5_ES6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/capturedLetConstInLoop5_ES6.ts(175,13): error TS2365: Operator '==' cannot be applied to types '0' and '1'. -tests/cases/compiler/capturedLetConstInLoop5_ES6.ts(230,13): error TS2365: Operator '==' cannot be applied to types '0' and '1'. +tests/cases/compiler/capturedLetConstInLoop5_ES6.ts(174,13): error TS2365: Operator '==' cannot be applied to types '0' and '1'. +tests/cases/compiler/capturedLetConstInLoop5_ES6.ts(229,13): error TS2365: Operator '==' cannot be applied to types '0' and '1'. ==== tests/cases/compiler/capturedLetConstInLoop5_ES6.ts (2 errors) ==== - declare function use(a: any); //====let diff --git a/tests/baselines/reference/capturedLetConstInLoop5_ES6.js b/tests/baselines/reference/capturedLetConstInLoop5_ES6.js index 0f0624b8a8b6d..da48929c959e8 100644 --- a/tests/baselines/reference/capturedLetConstInLoop5_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop5_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop5_ES6.ts] - declare function use(a: any); //====let diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js index a06d9c6f747fe..783140426d267 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js @@ -1,5 +1,4 @@ //// [capturedLetConstInLoop9_ES6.ts] - for (let x = 0; x < 1; ++x) { let x; (function() { return x }); diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols index c9b8fdb392c33..4d4013096fcc8 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols @@ -1,116 +1,115 @@ === tests/cases/compiler/capturedLetConstInLoop9_ES6.ts === - for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 8)) ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 0, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 0, 8)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 0, 8)) let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 7)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 7)) { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 4, 11)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 4, 11)) } try { } catch (e) { ->e : Symbol(e, Decl(capturedLetConstInLoop9_ES6.ts, 10, 11)) +>e : Symbol(e, Decl(capturedLetConstInLoop9_ES6.ts, 9, 11)) let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 11, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 10, 11)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 11, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 10, 11)) } switch (x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 7)) case 1: let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 17, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 16, 15)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 17, 15)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 16, 15)) break; } while (1 == 1) { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 23, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 22, 11)) (function() { return x }); ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 23, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 22, 11)) } class A { ->A : Symbol(A, Decl(capturedLetConstInLoop9_ES6.ts, 25, 5)) +>A : Symbol(A, Decl(capturedLetConstInLoop9_ES6.ts, 24, 5)) m() { ->m : Symbol(A.m, Decl(capturedLetConstInLoop9_ES6.ts, 27, 13)) +>m : Symbol(A.m, Decl(capturedLetConstInLoop9_ES6.ts, 26, 13)) return x + 1; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 7)) } } } declare function use(a: any); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 34, 21)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 33, 21)) function foo() { ->foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 34, 29)) +>foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 33, 29)) l0: for (let a of []) { ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 37, 12)) if (a === 1) { ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 37, 12)) break; } if (a === 2) { ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 37, 12)) break l0; } for (let b of []) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 47, 16)) var [{x, y:z}] = [{x:1, y:2}]; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 49, 18)) ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 49, 35)) ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 49, 20)) ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 49, 31)) ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 49, 35)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 48, 18)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 48, 35)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 48, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 48, 31)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 48, 35)) if (b === 1) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 47, 16)) break; } if (b === 2) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 47, 16)) break l0; } l1: if (b === 3) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 47, 16)) break l1; } @@ -119,77 +118,77 @@ function foo() { } for (let b of []) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 66, 16)) var [{x1, y:z1}] = [{x1:1, y:arguments.length}]; ->x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 18)) ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 68, 38)) ->z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 21)) ->x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 33)) ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 68, 38)) +>x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 18)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 67, 38)) +>z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 21)) +>x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 33)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 67, 38)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) if (b === 1) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 66, 16)) break; } if (b === 2) { ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 66, 16)) break l0; } () => b ->b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16)) +>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 66, 16)) return 100; } () => a; ->a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12)) +>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 37, 12)) } use(x); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 49, 18)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 48, 18)) use(z); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 49, 20)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 48, 20)) use(x1); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 18)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 18)) use(z1); ->use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1)) ->z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 21)) +>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 31, 1)) +>z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 21)) } function foo2() { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9_ES6.ts, 88, 1)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9_ES6.ts, 87, 1)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) if (x === 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) break; } else if (x === 2) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) continue; } while (1 === 1) { if (x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) break; } @@ -199,17 +198,17 @@ function foo2() { } switch(x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 90, 12)) case 1: break; case 2: continue; } for (let y of []) { ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 112, 16)) switch(y) { ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 112, 16)) case 1: break; case 2: continue; @@ -219,50 +218,50 @@ function foo2() { } class C { ->C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1)) +>C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 119, 1)) constructor(private N: number) { } ->N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16)) +>N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 122, 16)) foo() { ->foo : Symbol(C.foo, Decl(capturedLetConstInLoop9_ES6.ts, 123, 38)) +>foo : Symbol(C.foo, Decl(capturedLetConstInLoop9_ES6.ts, 122, 38)) for (let i = 0; i < 100; i++) { ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 124, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 124, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 124, 16)) let f = () => this.N * i; ->f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 126, 15)) ->this.N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16)) ->this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1)) ->N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) +>f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 125, 15)) +>this.N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 122, 16)) +>this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 119, 1)) +>N : Symbol(C.N, Decl(capturedLetConstInLoop9_ES6.ts, 122, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 124, 16)) } } } function foo3 () { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 129, 1)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 128, 1)) let x = arguments.length; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 132, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 131, 7)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) for (let y of []) { ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 133, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 132, 12)) let z = arguments.length; ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 11)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 133, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) (function() { return y + z + arguments.length; }); ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 133, 12)) ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 132, 12)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 133, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --)) diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types index be4457315eeeb..26d2b770a3118 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop9_ES6.ts === - for (let x = 0; x < 1; ++x) { >x : number >0 : 0 diff --git a/tests/baselines/reference/castExpressionParentheses.js b/tests/baselines/reference/castExpressionParentheses.js index 94d5daafb0a0e..b1f4507f98292 100644 --- a/tests/baselines/reference/castExpressionParentheses.js +++ b/tests/baselines/reference/castExpressionParentheses.js @@ -24,15 +24,15 @@ declare var a; (a[0]); (a.b["0"]); (a()).x; - -declare var A; - -// should keep the parentheses in emit (1).foo; (1.).foo; (1.0).foo; (12e+34).foo; (0xff).foo; + +declare var A; + +// should keep the parentheses in emit ((1.0)); (new A).foo; (typeof A).x; @@ -74,12 +74,12 @@ a; a[0]; a.b["0"]; a().x; +1..foo; +1..foo; +1.0.foo; +12e+34.foo; +0xff.foo; // should keep the parentheses in emit -(1).foo; -(1.).foo; -(1.0).foo; -(12e+34).foo; -(0xff).foo; (1.0); (new A).foo; (typeof A).x; diff --git a/tests/baselines/reference/castExpressionParentheses.symbols b/tests/baselines/reference/castExpressionParentheses.symbols index ef31ee0f226c2..df7ef6a1f2f7f 100644 --- a/tests/baselines/reference/castExpressionParentheses.symbols +++ b/tests/baselines/reference/castExpressionParentheses.symbols @@ -37,27 +37,28 @@ declare var a; (a()).x; >a : Symbol(a, Decl(castExpressionParentheses.ts, 0, 11)) -declare var A; ->A : Symbol(A, Decl(castExpressionParentheses.ts, 26, 11)) - -// should keep the parentheses in emit (1).foo; (1.).foo; (1.0).foo; (12e+34).foo; (0xff).foo; + +declare var A; +>A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11)) + +// should keep the parentheses in emit ((1.0)); (new A).foo; ->A : Symbol(A, Decl(castExpressionParentheses.ts, 26, 11)) +>A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11)) (typeof A).x; ->A : Symbol(A, Decl(castExpressionParentheses.ts, 26, 11)) +>A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11)) (-A).x; ->A : Symbol(A, Decl(castExpressionParentheses.ts, 26, 11)) +>A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11)) new (A()); ->A : Symbol(A, Decl(castExpressionParentheses.ts, 26, 11)) +>A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11)) (()=> {})(); >Tany : Symbol(Tany, Decl(castExpressionParentheses.ts, 39, 2)) @@ -66,14 +67,14 @@ new (A()); >foo : Symbol(foo, Decl(castExpressionParentheses.ts, 40, 6)) (-A).x; ->A : Symbol(A, Decl(castExpressionParentheses.ts, 26, 11)) +>A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11)) // nested cast, should keep one pair of parenthese ((-A)).x; ->A : Symbol(A, Decl(castExpressionParentheses.ts, 26, 11)) +>A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11)) // nested parenthesized expression, should keep one pair of parenthese ((A)) ->A : Symbol(A, Decl(castExpressionParentheses.ts, 26, 11)) +>A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11)) diff --git a/tests/baselines/reference/castExpressionParentheses.types b/tests/baselines/reference/castExpressionParentheses.types index aa633825eec99..5971b55f10339 100644 --- a/tests/baselines/reference/castExpressionParentheses.types +++ b/tests/baselines/reference/castExpressionParentheses.types @@ -125,10 +125,6 @@ declare var a; >a : any >x : any -declare var A; ->A : any - -// should keep the parentheses in emit (1).foo; >(1).foo : any >(1) : any @@ -164,6 +160,10 @@ declare var A; >0xff : 255 >foo : any +declare var A; +>A : any + +// should keep the parentheses in emit ((1.0)); >((1.0)) : any >(1.0) : any diff --git a/tests/baselines/reference/castTest.js b/tests/baselines/reference/castTest.js index ef9ef084d98e0..930086bdd9464 100644 --- a/tests/baselines/reference/castTest.js +++ b/tests/baselines/reference/castTest.js @@ -1,5 +1,4 @@ //// [castTest.ts] - var x : any = 0; var z = x; var y = x + z; diff --git a/tests/baselines/reference/castTest.symbols b/tests/baselines/reference/castTest.symbols index 944cc8238e6e4..9d03cb008ba4d 100644 --- a/tests/baselines/reference/castTest.symbols +++ b/tests/baselines/reference/castTest.symbols @@ -1,84 +1,83 @@ === tests/cases/compiler/castTest.ts === - var x : any = 0; ->x : Symbol(x, Decl(castTest.ts, 1, 3)) +>x : Symbol(x, Decl(castTest.ts, 0, 3)) var z = x; ->z : Symbol(z, Decl(castTest.ts, 2, 3)) ->x : Symbol(x, Decl(castTest.ts, 1, 3)) +>z : Symbol(z, Decl(castTest.ts, 1, 3)) +>x : Symbol(x, Decl(castTest.ts, 0, 3)) var y = x + z; ->y : Symbol(y, Decl(castTest.ts, 3, 3)) ->x : Symbol(x, Decl(castTest.ts, 1, 3)) ->z : Symbol(z, Decl(castTest.ts, 2, 3)) +>y : Symbol(y, Decl(castTest.ts, 2, 3)) +>x : Symbol(x, Decl(castTest.ts, 0, 3)) +>z : Symbol(z, Decl(castTest.ts, 1, 3)) var a = 0; ->a : Symbol(a, Decl(castTest.ts, 5, 3)) +>a : Symbol(a, Decl(castTest.ts, 4, 3)) var b = true; ->b : Symbol(b, Decl(castTest.ts, 6, 3)) +>b : Symbol(b, Decl(castTest.ts, 5, 3)) var s = ""; ->s : Symbol(s, Decl(castTest.ts, 7, 3)) +>s : Symbol(s, Decl(castTest.ts, 6, 3)) var ar = null; ->ar : Symbol(ar, Decl(castTest.ts, 9, 3)) +>ar : Symbol(ar, Decl(castTest.ts, 8, 3)) var f = <(res : number) => void>null; ->f : Symbol(f, Decl(castTest.ts, 11, 3)) ->res : Symbol(res, Decl(castTest.ts, 11, 10)) +>f : Symbol(f, Decl(castTest.ts, 10, 3)) +>res : Symbol(res, Decl(castTest.ts, 10, 10)) declare class Point ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) { x: number; ->x : Symbol(Point.x, Decl(castTest.ts, 14, 1)) +>x : Symbol(Point.x, Decl(castTest.ts, 13, 1)) y: number; ->y : Symbol(Point.y, Decl(castTest.ts, 15, 14)) +>y : Symbol(Point.y, Decl(castTest.ts, 14, 14)) add(dx: number, dy: number): Point; ->add : Symbol(Point.add, Decl(castTest.ts, 16, 14)) ->dx : Symbol(dx, Decl(castTest.ts, 17, 8)) ->dy : Symbol(dy, Decl(castTest.ts, 17, 19)) ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) +>add : Symbol(Point.add, Decl(castTest.ts, 15, 14)) +>dx : Symbol(dx, Decl(castTest.ts, 16, 8)) +>dy : Symbol(dy, Decl(castTest.ts, 16, 19)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) mult(p: Point): Point; ->mult : Symbol(Point.mult, Decl(castTest.ts, 17, 39)) ->p : Symbol(p, Decl(castTest.ts, 18, 9)) ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) +>mult : Symbol(Point.mult, Decl(castTest.ts, 16, 39)) +>p : Symbol(p, Decl(castTest.ts, 17, 9)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) constructor(x: number, y: number); ->x : Symbol(x, Decl(castTest.ts, 19, 16)) ->y : Symbol(y, Decl(castTest.ts, 19, 26)) +>x : Symbol(x, Decl(castTest.ts, 18, 16)) +>y : Symbol(y, Decl(castTest.ts, 18, 26)) } var p_cast = ({ ->p_cast : Symbol(p_cast, Decl(castTest.ts, 22, 3)) ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) +>p_cast : Symbol(p_cast, Decl(castTest.ts, 21, 3)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) x: 0, ->x : Symbol(x, Decl(castTest.ts, 22, 23)) +>x : Symbol(x, Decl(castTest.ts, 21, 23)) y: 0, ->y : Symbol(y, Decl(castTest.ts, 23, 9)) +>y : Symbol(y, Decl(castTest.ts, 22, 9)) add: function(dx, dy) { ->add : Symbol(add, Decl(castTest.ts, 24, 9)) ->dx : Symbol(dx, Decl(castTest.ts, 25, 18)) ->dy : Symbol(dy, Decl(castTest.ts, 25, 21)) +>add : Symbol(add, Decl(castTest.ts, 23, 9)) +>dx : Symbol(dx, Decl(castTest.ts, 24, 18)) +>dy : Symbol(dy, Decl(castTest.ts, 24, 21)) return new Point(this.x + dx, this.y + dy); ->Point : Symbol(Point, Decl(castTest.ts, 11, 37)) ->dx : Symbol(dx, Decl(castTest.ts, 25, 18)) ->dy : Symbol(dy, Decl(castTest.ts, 25, 21)) +>Point : Symbol(Point, Decl(castTest.ts, 10, 37)) +>dx : Symbol(dx, Decl(castTest.ts, 24, 18)) +>dy : Symbol(dy, Decl(castTest.ts, 24, 21)) }, mult: function(p) { return p; } ->mult : Symbol(mult, Decl(castTest.ts, 27, 6)) ->p : Symbol(p, Decl(castTest.ts, 28, 19)) ->p : Symbol(p, Decl(castTest.ts, 28, 19)) +>mult : Symbol(mult, Decl(castTest.ts, 26, 6)) +>p : Symbol(p, Decl(castTest.ts, 27, 19)) +>p : Symbol(p, Decl(castTest.ts, 27, 19)) }) diff --git a/tests/baselines/reference/castTest.types b/tests/baselines/reference/castTest.types index 666b2ccf78e05..4032aa8ac249a 100644 --- a/tests/baselines/reference/castTest.types +++ b/tests/baselines/reference/castTest.types @@ -1,5 +1,4 @@ === tests/cases/compiler/castTest.ts === - var x : any = 0; >x : any >0 : 0 diff --git a/tests/baselines/reference/checkJsFiles.errors.txt b/tests/baselines/reference/checkJsFiles.errors.txt new file mode 100644 index 0000000000000..4f6e59233b2fd --- /dev/null +++ b/tests/baselines/reference/checkJsFiles.errors.txt @@ -0,0 +1,8 @@ +tests/cases/compiler/a.js(2,1): error TS2322: Type '0' is not assignable to type 'string'. + + +==== tests/cases/compiler/a.js (1 errors) ==== + var x = "string"; + x = 0; + ~ +!!! error TS2322: Type '0' is not assignable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/checkJsFiles2.errors.txt b/tests/baselines/reference/checkJsFiles2.errors.txt new file mode 100644 index 0000000000000..2bdca3c8c18f7 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles2.errors.txt @@ -0,0 +1,9 @@ +tests/cases/compiler/a.js(3,1): error TS2322: Type '0' is not assignable to type 'string'. + + +==== tests/cases/compiler/a.js (1 errors) ==== + // @ts-check + var x = "string"; + x = 0; + ~ +!!! error TS2322: Type '0' is not assignable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/checkJsFiles3.errors.txt b/tests/baselines/reference/checkJsFiles3.errors.txt new file mode 100644 index 0000000000000..2bdca3c8c18f7 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles3.errors.txt @@ -0,0 +1,9 @@ +tests/cases/compiler/a.js(3,1): error TS2322: Type '0' is not assignable to type 'string'. + + +==== tests/cases/compiler/a.js (1 errors) ==== + // @ts-check + var x = "string"; + x = 0; + ~ +!!! error TS2322: Type '0' is not assignable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/checkJsFiles4.errors.txt b/tests/baselines/reference/checkJsFiles4.errors.txt new file mode 100644 index 0000000000000..2bdca3c8c18f7 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles4.errors.txt @@ -0,0 +1,9 @@ +tests/cases/compiler/a.js(3,1): error TS2322: Type '0' is not assignable to type 'string'. + + +==== tests/cases/compiler/a.js (1 errors) ==== + // @ts-check + var x = "string"; + x = 0; + ~ +!!! error TS2322: Type '0' is not assignable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/checkJsFiles5.symbols b/tests/baselines/reference/checkJsFiles5.symbols new file mode 100644 index 0000000000000..696a706601ded --- /dev/null +++ b/tests/baselines/reference/checkJsFiles5.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/a.js === +// @ts-nocheck +var x = "string"; +>x : Symbol(x, Decl(a.js, 1, 3)) + +x = 0; +>x : Symbol(x, Decl(a.js, 1, 3)) + diff --git a/tests/baselines/reference/checkJsFiles5.types b/tests/baselines/reference/checkJsFiles5.types new file mode 100644 index 0000000000000..f566230948a2d --- /dev/null +++ b/tests/baselines/reference/checkJsFiles5.types @@ -0,0 +1,11 @@ +=== tests/cases/compiler/a.js === +// @ts-nocheck +var x = "string"; +>x : string +>"string" : "string" + +x = 0; +>x = 0 : 0 +>x : string +>0 : 0 + diff --git a/tests/baselines/reference/checkJsFiles6.errors.txt b/tests/baselines/reference/checkJsFiles6.errors.txt new file mode 100644 index 0000000000000..fa41e063819e7 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles6.errors.txt @@ -0,0 +1,8 @@ +error TS5052: Option 'checkJs' cannot be specified without specifying option 'allowJs'. +error TS6054: File 'tests/cases/compiler/a.js' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts'. + + +!!! error TS5052: Option 'checkJs' cannot be specified without specifying option 'allowJs'. +!!! error TS6054: File 'tests/cases/compiler/a.js' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts'. +==== tests/cases/compiler/a.js (0 errors) ==== + var x; \ No newline at end of file diff --git a/tests/baselines/reference/checkJsFiles_skipDiagnostics.symbols b/tests/baselines/reference/checkJsFiles_skipDiagnostics.symbols new file mode 100644 index 0000000000000..5d9aa8c53c563 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles_skipDiagnostics.symbols @@ -0,0 +1,37 @@ +=== tests/cases/compiler/a.js === +var x = 0; +>x : Symbol(x, Decl(a.js, 0, 3)) + + +/// @ts-ignore +x(); +>x : Symbol(x, Decl(a.js, 0, 3)) + +/// @ts-ignore +x(); +>x : Symbol(x, Decl(a.js, 0, 3)) + +/// @ts-ignore +x( +>x : Symbol(x, Decl(a.js, 0, 3)) + + 2, + 3); + + + +// @ts-ignore +// come comment +// some other comment + +// @anohter + +x(); +>x : Symbol(x, Decl(a.js, 0, 3)) + + + +// @ts-ignore: no call signature +x(); +>x : Symbol(x, Decl(a.js, 0, 3)) + diff --git a/tests/baselines/reference/checkJsFiles_skipDiagnostics.types b/tests/baselines/reference/checkJsFiles_skipDiagnostics.types new file mode 100644 index 0000000000000..a07bf43901b32 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles_skipDiagnostics.types @@ -0,0 +1,46 @@ +=== tests/cases/compiler/a.js === +var x = 0; +>x : number +>0 : 0 + + +/// @ts-ignore +x(); +>x() : any +>x : number + +/// @ts-ignore +x(); +>x() : any +>x : number + +/// @ts-ignore +x( +>x( 2, 3) : any +>x : number + + 2, +>2 : 2 + + 3); +>3 : 3 + + + +// @ts-ignore +// come comment +// some other comment + +// @anohter + +x(); +>x() : any +>x : number + + + +// @ts-ignore: no call signature +x(); +>x() : any +>x : number + diff --git a/tests/baselines/reference/circularIndexedAccessErrors.errors.txt b/tests/baselines/reference/circularIndexedAccessErrors.errors.txt index f76cfca073e74..d2e9171065b2b 100644 --- a/tests/baselines/reference/circularIndexedAccessErrors.errors.txt +++ b/tests/baselines/reference/circularIndexedAccessErrors.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(3,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(7,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(19,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(23,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(38,24): error TS2313: Type parameter 'T' has a circular constraint. -tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(38,30): error TS2536: Type '"hello"' cannot be used to index type 'T'. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(2,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(6,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(18,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(22,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(37,24): error TS2313: Type parameter 'T' has a circular constraint. +tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts(37,30): error TS2536: Type '"hello"' cannot be used to index type 'T'. ==== tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts (6 errors) ==== - type T1 = { x: T1["x"]; // Error ~~~~~~~~~~~ diff --git a/tests/baselines/reference/circularIndexedAccessErrors.js b/tests/baselines/reference/circularIndexedAccessErrors.js index 97d059bce19bc..eee09e853a2fd 100644 --- a/tests/baselines/reference/circularIndexedAccessErrors.js +++ b/tests/baselines/reference/circularIndexedAccessErrors.js @@ -1,5 +1,4 @@ //// [circularIndexedAccessErrors.ts] - type T1 = { x: T1["x"]; // Error }; diff --git a/tests/baselines/reference/circularInferredTypeOfVariable.js b/tests/baselines/reference/circularInferredTypeOfVariable.js index 38c5334761a9b..e7ba96ebaf81c 100644 --- a/tests/baselines/reference/circularInferredTypeOfVariable.js +++ b/tests/baselines/reference/circularInferredTypeOfVariable.js @@ -1,5 +1,4 @@ //// [circularInferredTypeOfVariable.ts] - // Repro from #14428 (async () => { diff --git a/tests/baselines/reference/circularInferredTypeOfVariable.symbols b/tests/baselines/reference/circularInferredTypeOfVariable.symbols index 653978f0e83b5..a5f3d8990c5fc 100644 --- a/tests/baselines/reference/circularInferredTypeOfVariable.symbols +++ b/tests/baselines/reference/circularInferredTypeOfVariable.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/circularInferredTypeOfVariable.ts === - // Repro from #14428 (async () => { function foo(p: string[]): string[] { ->foo : Symbol(foo, Decl(circularInferredTypeOfVariable.ts, 3, 14)) ->p : Symbol(p, Decl(circularInferredTypeOfVariable.ts, 4, 17)) +>foo : Symbol(foo, Decl(circularInferredTypeOfVariable.ts, 2, 14)) +>p : Symbol(p, Decl(circularInferredTypeOfVariable.ts, 3, 17)) return []; } function bar(p: string[]): string[] { ->bar : Symbol(bar, Decl(circularInferredTypeOfVariable.ts, 6, 5)) ->p : Symbol(p, Decl(circularInferredTypeOfVariable.ts, 8, 17)) +>bar : Symbol(bar, Decl(circularInferredTypeOfVariable.ts, 5, 5)) +>p : Symbol(p, Decl(circularInferredTypeOfVariable.ts, 7, 17)) return []; } let a1: string[] | undefined = []; ->a1 : Symbol(a1, Decl(circularInferredTypeOfVariable.ts, 12, 7)) +>a1 : Symbol(a1, Decl(circularInferredTypeOfVariable.ts, 11, 7)) while (true) { let a2 = foo(a1!); ->a2 : Symbol(a2, Decl(circularInferredTypeOfVariable.ts, 15, 11)) ->foo : Symbol(foo, Decl(circularInferredTypeOfVariable.ts, 3, 14)) ->a1 : Symbol(a1, Decl(circularInferredTypeOfVariable.ts, 12, 7)) +>a2 : Symbol(a2, Decl(circularInferredTypeOfVariable.ts, 14, 11)) +>foo : Symbol(foo, Decl(circularInferredTypeOfVariable.ts, 2, 14)) +>a1 : Symbol(a1, Decl(circularInferredTypeOfVariable.ts, 11, 7)) a1 = await bar(a2); ->a1 : Symbol(a1, Decl(circularInferredTypeOfVariable.ts, 12, 7)) ->bar : Symbol(bar, Decl(circularInferredTypeOfVariable.ts, 6, 5)) ->a2 : Symbol(a2, Decl(circularInferredTypeOfVariable.ts, 15, 11)) +>a1 : Symbol(a1, Decl(circularInferredTypeOfVariable.ts, 11, 7)) +>bar : Symbol(bar, Decl(circularInferredTypeOfVariable.ts, 5, 5)) +>a2 : Symbol(a2, Decl(circularInferredTypeOfVariable.ts, 14, 11)) } }); diff --git a/tests/baselines/reference/circularInferredTypeOfVariable.types b/tests/baselines/reference/circularInferredTypeOfVariable.types index df227bd9ae001..c0ddb43fd8bd9 100644 --- a/tests/baselines/reference/circularInferredTypeOfVariable.types +++ b/tests/baselines/reference/circularInferredTypeOfVariable.types @@ -1,5 +1,4 @@ === tests/cases/compiler/circularInferredTypeOfVariable.ts === - // Repro from #14428 (async () => { diff --git a/tests/baselines/reference/circularObjectLiteralAccessors.js b/tests/baselines/reference/circularObjectLiteralAccessors.js index 6d99a8f25fcb6..34d114268caea 100644 --- a/tests/baselines/reference/circularObjectLiteralAccessors.js +++ b/tests/baselines/reference/circularObjectLiteralAccessors.js @@ -1,5 +1,4 @@ //// [circularObjectLiteralAccessors.ts] - // Repro from #6000 const a = { diff --git a/tests/baselines/reference/circularObjectLiteralAccessors.symbols b/tests/baselines/reference/circularObjectLiteralAccessors.symbols index 21e613c97feec..ef2b6606d00e1 100644 --- a/tests/baselines/reference/circularObjectLiteralAccessors.symbols +++ b/tests/baselines/reference/circularObjectLiteralAccessors.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/circularObjectLiteralAccessors.ts === - // Repro from #6000 const a = { ->a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 3, 5)) +>a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 2, 5)) b: { ->b : Symbol(b, Decl(circularObjectLiteralAccessors.ts, 3, 11)) +>b : Symbol(b, Decl(circularObjectLiteralAccessors.ts, 2, 11)) get foo(): string { ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 4, 8), Decl(circularObjectLiteralAccessors.ts, 7, 10)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 3, 8), Decl(circularObjectLiteralAccessors.ts, 6, 10)) return a.foo; ->a.foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) ->a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 3, 5)) ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) +>a.foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) +>a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 2, 5)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) }, set foo(value: string) { ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 4, 8), Decl(circularObjectLiteralAccessors.ts, 7, 10)) ->value : Symbol(value, Decl(circularObjectLiteralAccessors.ts, 8, 16)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 3, 8), Decl(circularObjectLiteralAccessors.ts, 6, 10)) +>value : Symbol(value, Decl(circularObjectLiteralAccessors.ts, 7, 16)) a.foo = value; ->a.foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) ->a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 3, 5)) ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) ->value : Symbol(value, Decl(circularObjectLiteralAccessors.ts, 8, 16)) +>a.foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) +>a : Symbol(a, Decl(circularObjectLiteralAccessors.ts, 2, 5)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) +>value : Symbol(value, Decl(circularObjectLiteralAccessors.ts, 7, 16)) } }, foo: '' ->foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 11, 6)) +>foo : Symbol(foo, Decl(circularObjectLiteralAccessors.ts, 10, 6)) }; diff --git a/tests/baselines/reference/circularObjectLiteralAccessors.types b/tests/baselines/reference/circularObjectLiteralAccessors.types index e190ea5e6d3f1..361f063780bb7 100644 --- a/tests/baselines/reference/circularObjectLiteralAccessors.types +++ b/tests/baselines/reference/circularObjectLiteralAccessors.types @@ -1,5 +1,4 @@ === tests/cases/compiler/circularObjectLiteralAccessors.ts === - // Repro from #6000 const a = { diff --git a/tests/baselines/reference/circularReferenceInImport.js b/tests/baselines/reference/circularReferenceInImport.js index 8b49f45dbd205..432a03d090cac 100644 --- a/tests/baselines/reference/circularReferenceInImport.js +++ b/tests/baselines/reference/circularReferenceInImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/circularReferenceInImport.ts] //// //// [db.d.ts] - declare namespace Db { export import Types = Db; } diff --git a/tests/baselines/reference/circularReferenceInImport.symbols b/tests/baselines/reference/circularReferenceInImport.symbols index b74ac14b5ab26..d5415f1fef173 100644 --- a/tests/baselines/reference/circularReferenceInImport.symbols +++ b/tests/baselines/reference/circularReferenceInImport.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/db.d.ts === - declare namespace Db { >Db : Symbol(Types, Decl(db.d.ts, 0, 0)) export import Types = Db; ->Types : Symbol(Types, Decl(db.d.ts, 1, 22)) +>Types : Symbol(Types, Decl(db.d.ts, 0, 22)) >Db : Symbol(Types, Decl(db.d.ts, 0, 0)) } diff --git a/tests/baselines/reference/circularReferenceInImport.types b/tests/baselines/reference/circularReferenceInImport.types index d8db7f56231a0..72e5f2e301ccf 100644 --- a/tests/baselines/reference/circularReferenceInImport.types +++ b/tests/baselines/reference/circularReferenceInImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/db.d.ts === - declare namespace Db { >Db : typeof Types diff --git a/tests/baselines/reference/classAbstractAccessor.errors.txt b/tests/baselines/reference/classAbstractAccessor.errors.txt index b43cfa9d7f13e..9afc61fb5fbe1 100644 --- a/tests/baselines/reference/classAbstractAccessor.errors.txt +++ b/tests/baselines/reference/classAbstractAccessor.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts(4,17): error TS1318: An abstract accessor cannot have an implementation. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts(6,17): error TS1318: An abstract accessor cannot have an implementation. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts(3,17): error TS1318: An abstract accessor cannot have an implementation. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts(5,17): error TS1318: An abstract accessor cannot have an implementation. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAccessor.ts (2 errors) ==== - abstract class A { abstract get a(); abstract get aa() { return 1; } // error diff --git a/tests/baselines/reference/classAbstractAccessor.js b/tests/baselines/reference/classAbstractAccessor.js index a1edf0cb88d6f..d953a4ac0c22e 100644 --- a/tests/baselines/reference/classAbstractAccessor.js +++ b/tests/baselines/reference/classAbstractAccessor.js @@ -1,5 +1,4 @@ //// [classAbstractAccessor.ts] - abstract class A { abstract get a(); abstract get aa() { return 1; } // error diff --git a/tests/baselines/reference/classAbstractConstructorAssignability.errors.txt b/tests/baselines/reference/classAbstractConstructorAssignability.errors.txt index a3e9e07791491..0f83466534635 100644 --- a/tests/baselines/reference/classAbstractConstructorAssignability.errors.txt +++ b/tests/baselines/reference/classAbstractConstructorAssignability.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(8,5): error TS2322: Type 'typeof B' is not assignable to type 'typeof A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(7,5): error TS2322: Type 'typeof B' is not assignable to type 'typeof A'. Cannot assign an abstract constructor type to a non-abstract constructor type. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(10,5): error TS2322: Type 'typeof B' is not assignable to type 'typeof C'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(9,5): error TS2322: Type 'typeof B' is not assignable to type 'typeof C'. Cannot assign an abstract constructor type to a non-abstract constructor type. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(13,1): error TS2511: Cannot create an instance of the abstract class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts(12,1): error TS2511: Cannot create an instance of the abstract class 'B'. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructorAssignability.ts (3 errors) ==== - class A {} abstract class B extends A {} diff --git a/tests/baselines/reference/classAbstractConstructorAssignability.js b/tests/baselines/reference/classAbstractConstructorAssignability.js index 5df6d169e04c1..8376e5c1a45a8 100644 --- a/tests/baselines/reference/classAbstractConstructorAssignability.js +++ b/tests/baselines/reference/classAbstractConstructorAssignability.js @@ -1,5 +1,4 @@ //// [classAbstractConstructorAssignability.ts] - class A {} abstract class B extends A {} diff --git a/tests/baselines/reference/classAbstractExtends.errors.txt b/tests/baselines/reference/classAbstractExtends.errors.txt index 550067cd0e128..60b0f9ae0ac42 100644 --- a/tests/baselines/reference/classAbstractExtends.errors.txt +++ b/tests/baselines/reference/classAbstractExtends.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractExtends.ts(10,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'bar' from class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractExtends.ts(9,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'bar' from class 'B'. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractExtends.ts (1 errors) ==== - class A { foo() {} } diff --git a/tests/baselines/reference/classAbstractExtends.js b/tests/baselines/reference/classAbstractExtends.js index 69c962509dbe0..0f63a08d2e9f0 100644 --- a/tests/baselines/reference/classAbstractExtends.js +++ b/tests/baselines/reference/classAbstractExtends.js @@ -1,5 +1,4 @@ //// [classAbstractExtends.ts] - class A { foo() {} } diff --git a/tests/baselines/reference/classAbstractFactoryFunction.errors.txt b/tests/baselines/reference/classAbstractFactoryFunction.errors.txt index f1b43adae59aa..1b281f35260d4 100644 --- a/tests/baselines/reference/classAbstractFactoryFunction.errors.txt +++ b/tests/baselines/reference/classAbstractFactoryFunction.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts(10,12): error TS2511: Cannot create an instance of the abstract class 'B'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts(14,6): error TS2345: Argument of type 'typeof B' is not assignable to parameter of type 'typeof A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts(9,12): error TS2511: Cannot create an instance of the abstract class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts(13,6): error TS2345: Argument of type 'typeof B' is not assignable to parameter of type 'typeof A'. Cannot assign an abstract constructor type to a non-abstract constructor type. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractFactoryFunction.ts (2 errors) ==== - class A {} abstract class B extends A {} diff --git a/tests/baselines/reference/classAbstractFactoryFunction.js b/tests/baselines/reference/classAbstractFactoryFunction.js index abc3235a3d38f..903faf53a508e 100644 --- a/tests/baselines/reference/classAbstractFactoryFunction.js +++ b/tests/baselines/reference/classAbstractFactoryFunction.js @@ -1,5 +1,4 @@ //// [classAbstractFactoryFunction.ts] - class A {} abstract class B extends A {} diff --git a/tests/baselines/reference/classAbstractInstantiations1.errors.txt b/tests/baselines/reference/classAbstractInstantiations1.errors.txt index 24a969fc6b8c8..d1c159858a469 100644 --- a/tests/baselines/reference/classAbstractInstantiations1.errors.txt +++ b/tests/baselines/reference/classAbstractInstantiations1.errors.txt @@ -1,10 +1,9 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(11,1): error TS2511: Cannot create an instance of the abstract class 'A'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(12,1): error TS2511: Cannot create an instance of the abstract class 'A'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(13,1): error TS2511: Cannot create an instance of the abstract class 'A'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(15,1): error TS2511: Cannot create an instance of the abstract class 'C'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(14,1): error TS2511: Cannot create an instance of the abstract class 'C'. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts (3 errors) ==== - // // Calling new with (non)abstract classes. // diff --git a/tests/baselines/reference/classAbstractInstantiations1.js b/tests/baselines/reference/classAbstractInstantiations1.js index 6722665b62d5d..df69dbac8eead 100644 --- a/tests/baselines/reference/classAbstractInstantiations1.js +++ b/tests/baselines/reference/classAbstractInstantiations1.js @@ -1,5 +1,4 @@ //// [classAbstractInstantiations1.ts] - // // Calling new with (non)abstract classes. // diff --git a/tests/baselines/reference/classAbstractManyKeywords.errors.txt b/tests/baselines/reference/classAbstractManyKeywords.errors.txt index 8f9e3fed18eb0..1b23bfac98298 100644 --- a/tests/baselines/reference/classAbstractManyKeywords.errors.txt +++ b/tests/baselines/reference/classAbstractManyKeywords.errors.txt @@ -1,12 +1,9 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts(1,25): error TS1005: ';' expected. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts(3,1): error TS1128: Declaration or statement expected. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts(4,17): error TS1005: '=' expected. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts (3 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts (2 errors) ==== export default abstract class A {} - ~~~~~ -!!! error TS1005: ';' expected. export abstract class B {} default abstract class C {} ~~~~~~~ diff --git a/tests/baselines/reference/classAbstractManyKeywords.js b/tests/baselines/reference/classAbstractManyKeywords.js index 8ba50dcee1c62..c2af09eb4d8f8 100644 --- a/tests/baselines/reference/classAbstractManyKeywords.js +++ b/tests/baselines/reference/classAbstractManyKeywords.js @@ -7,12 +7,12 @@ import abstract class D {} //// [classAbstractManyKeywords.js] "use strict"; exports.__esModule = true; -exports["default"] = abstract; var A = (function () { function A() { } return A; }()); +exports["default"] = A; var B = (function () { function B() { } @@ -24,7 +24,6 @@ var C = (function () { } return C; }()); -var abstract = ; var D = (function () { function D() { } diff --git a/tests/baselines/reference/classAbstractSuperCalls.errors.txt b/tests/baselines/reference/classAbstractSuperCalls.errors.txt index a9dbf0f7ba8ce..771d0369890b1 100644 --- a/tests/baselines/reference/classAbstractSuperCalls.errors.txt +++ b/tests/baselines/reference/classAbstractSuperCalls.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,26): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,41): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(13,26): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(13,41): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts (2 errors) ==== - class A { foo() { return 1; } } diff --git a/tests/baselines/reference/classAbstractSuperCalls.js b/tests/baselines/reference/classAbstractSuperCalls.js index 125f5b3883fc6..9bba784ca9360 100644 --- a/tests/baselines/reference/classAbstractSuperCalls.js +++ b/tests/baselines/reference/classAbstractSuperCalls.js @@ -1,5 +1,4 @@ //// [classAbstractSuperCalls.ts] - class A { foo() { return 1; } } diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.symbols b/tests/baselines/reference/classAndInterfaceMerge.d.symbols index 84fc2b129c145..ff909ad492343 100644 --- a/tests/baselines/reference/classAndInterfaceMerge.d.symbols +++ b/tests/baselines/reference/classAndInterfaceMerge.d.symbols @@ -1,39 +1,38 @@ === tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts === - interface C { } ->C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 0, 15), Decl(classAndInterfaceMerge.d.ts, 2, 19), Decl(classAndInterfaceMerge.d.ts, 4, 15)) declare class C { } ->C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 0, 15), Decl(classAndInterfaceMerge.d.ts, 2, 19), Decl(classAndInterfaceMerge.d.ts, 4, 15)) interface C { } ->C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 0, 15), Decl(classAndInterfaceMerge.d.ts, 2, 19), Decl(classAndInterfaceMerge.d.ts, 4, 15)) interface C { } ->C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 0, 15), Decl(classAndInterfaceMerge.d.ts, 2, 19), Decl(classAndInterfaceMerge.d.ts, 4, 15)) declare module M { ->M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 7, 15), Decl(classAndInterfaceMerge.d.ts, 20, 1)) +>M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 6, 15), Decl(classAndInterfaceMerge.d.ts, 19, 1)) interface C1 { } ->C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 8, 18), Decl(classAndInterfaceMerge.d.ts, 10, 20), Decl(classAndInterfaceMerge.d.ts, 12, 16), Decl(classAndInterfaceMerge.d.ts, 14, 20)) class C1 { } ->C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 8, 18), Decl(classAndInterfaceMerge.d.ts, 10, 20), Decl(classAndInterfaceMerge.d.ts, 12, 16), Decl(classAndInterfaceMerge.d.ts, 14, 20)) interface C1 { } ->C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 8, 18), Decl(classAndInterfaceMerge.d.ts, 10, 20), Decl(classAndInterfaceMerge.d.ts, 12, 16), Decl(classAndInterfaceMerge.d.ts, 14, 20)) interface C1 { } ->C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 8, 18), Decl(classAndInterfaceMerge.d.ts, 10, 20), Decl(classAndInterfaceMerge.d.ts, 12, 16), Decl(classAndInterfaceMerge.d.ts, 14, 20)) export class C2 { } ->C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 17, 20), Decl(classAndInterfaceMerge.d.ts, 22, 18)) +>C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 16, 20), Decl(classAndInterfaceMerge.d.ts, 21, 18)) } declare module M { ->M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 7, 15), Decl(classAndInterfaceMerge.d.ts, 20, 1)) +>M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 6, 15), Decl(classAndInterfaceMerge.d.ts, 19, 1)) export interface C2 { } ->C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 17, 20), Decl(classAndInterfaceMerge.d.ts, 22, 18)) +>C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 16, 20), Decl(classAndInterfaceMerge.d.ts, 21, 18)) } diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.types b/tests/baselines/reference/classAndInterfaceMerge.d.types index baab121ca6ea6..2a7bbb86bedc8 100644 --- a/tests/baselines/reference/classAndInterfaceMerge.d.types +++ b/tests/baselines/reference/classAndInterfaceMerge.d.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts === - interface C { } >C : C diff --git a/tests/baselines/reference/classConstructorAccessibility.errors.txt b/tests/baselines/reference/classConstructorAccessibility.errors.txt index c79633ba33d92..c05f57e22b98f 100644 --- a/tests/baselines/reference/classConstructorAccessibility.errors.txt +++ b/tests/baselines/reference/classConstructorAccessibility.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(15,9): error TS2673: Constructor of class 'D' is private and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(16,9): error TS2674: Constructor of class 'E' is protected and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(32,13): error TS2673: Constructor of class 'D' is private and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(33,13): error TS2674: Constructor of class 'E' is protected and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(14,9): error TS2673: Constructor of class 'D' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(15,9): error TS2674: Constructor of class 'E' is protected and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(31,13): error TS2673: Constructor of class 'D' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts(32,13): error TS2674: Constructor of class 'E' is protected and only accessible within the class declaration. ==== tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility.ts (4 errors) ==== - class C { public constructor(public x: number) { } } diff --git a/tests/baselines/reference/classConstructorAccessibility.js b/tests/baselines/reference/classConstructorAccessibility.js index efc3f3c273cfa..46a548d0b5418 100644 --- a/tests/baselines/reference/classConstructorAccessibility.js +++ b/tests/baselines/reference/classConstructorAccessibility.js @@ -1,5 +1,4 @@ //// [classConstructorAccessibility.ts] - class C { public constructor(public x: number) { } } diff --git a/tests/baselines/reference/classConstructorAccessibility2.errors.txt b/tests/baselines/reference/classConstructorAccessibility2.errors.txt index 337e9787e5e3f..2bb111617cda9 100644 --- a/tests/baselines/reference/classConstructorAccessibility2.errors.txt +++ b/tests/baselines/reference/classConstructorAccessibility2.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(32,24): error TS2675: Cannot extend a class 'BaseC'. Class constructor is marked as private. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(35,28): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(36,35): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(40,10): error TS2674: Constructor of class 'BaseB' is protected and only accessible within the class declaration. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(41,10): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(31,24): error TS2675: Cannot extend a class 'BaseC'. Class constructor is marked as private. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(34,28): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(35,35): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(39,10): error TS2674: Constructor of class 'BaseB' is protected and only accessible within the class declaration. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts(40,10): error TS2673: Constructor of class 'BaseC' is private and only accessible within the class declaration. ==== tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility2.ts (5 errors) ==== - class BaseA { public constructor(public x: number) { } createInstance() { new BaseA(1); } diff --git a/tests/baselines/reference/classConstructorAccessibility2.js b/tests/baselines/reference/classConstructorAccessibility2.js index 7c77d13dffbee..7297af11a4ebe 100644 --- a/tests/baselines/reference/classConstructorAccessibility2.js +++ b/tests/baselines/reference/classConstructorAccessibility2.js @@ -1,5 +1,4 @@ //// [classConstructorAccessibility2.ts] - class BaseA { public constructor(public x: number) { } createInstance() { new BaseA(1); } diff --git a/tests/baselines/reference/classConstructorAccessibility3.errors.txt b/tests/baselines/reference/classConstructorAccessibility3.errors.txt index 1b96db289dc79..57fc9f58c1fc4 100644 --- a/tests/baselines/reference/classConstructorAccessibility3.errors.txt +++ b/tests/baselines/reference/classConstructorAccessibility3.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(21,1): error TS2322: Type 'typeof Baz' is not assignable to type 'typeof Foo'. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(20,1): error TS2322: Type 'typeof Baz' is not assignable to type 'typeof Foo'. Cannot assign a 'protected' constructor type to a 'public' constructor type. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(22,1): error TS2322: Type 'typeof Qux' is not assignable to type 'typeof Foo'. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(21,1): error TS2322: Type 'typeof Qux' is not assignable to type 'typeof Foo'. Cannot assign a 'private' constructor type to a 'public' constructor type. -tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(28,1): error TS2322: Type 'typeof Qux' is not assignable to type 'typeof Baz'. +tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts(27,1): error TS2322: Type 'typeof Qux' is not assignable to type 'typeof Baz'. Cannot assign a 'private' constructor type to a 'protected' constructor type. ==== tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility3.ts (3 errors) ==== - class Foo { constructor(public x: number) { } } diff --git a/tests/baselines/reference/classConstructorAccessibility3.js b/tests/baselines/reference/classConstructorAccessibility3.js index acc7d38aa5534..3e024970bcfd4 100644 --- a/tests/baselines/reference/classConstructorAccessibility3.js +++ b/tests/baselines/reference/classConstructorAccessibility3.js @@ -1,5 +1,4 @@ //// [classConstructorAccessibility3.ts] - class Foo { constructor(public x: number) { } } diff --git a/tests/baselines/reference/classConstructorAccessibility4.js b/tests/baselines/reference/classConstructorAccessibility4.js index f6370729971a6..032d4f8c13d7b 100644 --- a/tests/baselines/reference/classConstructorAccessibility4.js +++ b/tests/baselines/reference/classConstructorAccessibility4.js @@ -1,5 +1,4 @@ //// [classConstructorAccessibility4.ts] - class A { private constructor() { } diff --git a/tests/baselines/reference/classConstructorAccessibility4.symbols b/tests/baselines/reference/classConstructorAccessibility4.symbols index 66a9bbfabfdf2..18edada13ca3b 100644 --- a/tests/baselines/reference/classConstructorAccessibility4.symbols +++ b/tests/baselines/reference/classConstructorAccessibility4.symbols @@ -1,18 +1,17 @@ === tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility4.ts === - class A { >A : Symbol(A, Decl(classConstructorAccessibility4.ts, 0, 0)) private constructor() { } method() { ->method : Symbol(A.method, Decl(classConstructorAccessibility4.ts, 2, 29)) +>method : Symbol(A.method, Decl(classConstructorAccessibility4.ts, 1, 29)) class B { ->B : Symbol(B, Decl(classConstructorAccessibility4.ts, 4, 14)) +>B : Symbol(B, Decl(classConstructorAccessibility4.ts, 3, 14)) method() { ->method : Symbol(B.method, Decl(classConstructorAccessibility4.ts, 5, 17)) +>method : Symbol(B.method, Decl(classConstructorAccessibility4.ts, 4, 17)) new A(); // OK >A : Symbol(A, Decl(classConstructorAccessibility4.ts, 0, 0)) @@ -20,34 +19,34 @@ class A { } class C extends A { // OK ->C : Symbol(C, Decl(classConstructorAccessibility4.ts, 9, 9)) +>C : Symbol(C, Decl(classConstructorAccessibility4.ts, 8, 9)) >A : Symbol(A, Decl(classConstructorAccessibility4.ts, 0, 0)) } } } class D { ->D : Symbol(D, Decl(classConstructorAccessibility4.ts, 14, 1)) +>D : Symbol(D, Decl(classConstructorAccessibility4.ts, 13, 1)) protected constructor() { } method() { ->method : Symbol(D.method, Decl(classConstructorAccessibility4.ts, 17, 31)) +>method : Symbol(D.method, Decl(classConstructorAccessibility4.ts, 16, 31)) class E { ->E : Symbol(E, Decl(classConstructorAccessibility4.ts, 19, 14)) +>E : Symbol(E, Decl(classConstructorAccessibility4.ts, 18, 14)) method() { ->method : Symbol(E.method, Decl(classConstructorAccessibility4.ts, 20, 17)) +>method : Symbol(E.method, Decl(classConstructorAccessibility4.ts, 19, 17)) new D(); // OK ->D : Symbol(D, Decl(classConstructorAccessibility4.ts, 14, 1)) +>D : Symbol(D, Decl(classConstructorAccessibility4.ts, 13, 1)) } } class F extends D { // OK ->F : Symbol(F, Decl(classConstructorAccessibility4.ts, 24, 9)) ->D : Symbol(D, Decl(classConstructorAccessibility4.ts, 14, 1)) +>F : Symbol(F, Decl(classConstructorAccessibility4.ts, 23, 9)) +>D : Symbol(D, Decl(classConstructorAccessibility4.ts, 13, 1)) } } } diff --git a/tests/baselines/reference/classConstructorAccessibility4.types b/tests/baselines/reference/classConstructorAccessibility4.types index 1eb5a25e2208b..46de799479289 100644 --- a/tests/baselines/reference/classConstructorAccessibility4.types +++ b/tests/baselines/reference/classConstructorAccessibility4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/constructorDeclarations/classConstructorAccessibility4.ts === - class A { >A : A diff --git a/tests/baselines/reference/classConstructorOverloadsAccessibility.errors.txt b/tests/baselines/reference/classConstructorOverloadsAccessibility.errors.txt index 8882b9f018038..4f4bca4eb6937 100644 --- a/tests/baselines/reference/classConstructorOverloadsAccessibility.errors.txt +++ b/tests/baselines/reference/classConstructorOverloadsAccessibility.errors.txt @@ -1,10 +1,9 @@ +tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(2,2): error TS2385: Overload signatures must all be public, private or protected. tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(3,2): error TS2385: Overload signatures must all be public, private or protected. -tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(4,2): error TS2385: Overload signatures must all be public, private or protected. -tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(12,2): error TS2385: Overload signatures must all be public, private or protected. +tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts(11,2): error TS2385: Overload signatures must all be public, private or protected. ==== tests/cases/conformance/classes/constructorDeclarations/classConstructorOverloadsAccessibility.ts (3 errors) ==== - class A { public constructor(a: boolean) // error ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/tests/baselines/reference/classConstructorOverloadsAccessibility.js b/tests/baselines/reference/classConstructorOverloadsAccessibility.js index 3914c29b78525..7fef7443c6296 100644 --- a/tests/baselines/reference/classConstructorOverloadsAccessibility.js +++ b/tests/baselines/reference/classConstructorOverloadsAccessibility.js @@ -1,5 +1,4 @@ //// [classConstructorOverloadsAccessibility.ts] - class A { public constructor(a: boolean) // error protected constructor(a: number) // error diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.js b/tests/baselines/reference/classExpressionWithStaticProperties3.js index 7bec5fca16733..ca6f6608b7548 100644 --- a/tests/baselines/reference/classExpressionWithStaticProperties3.js +++ b/tests/baselines/reference/classExpressionWithStaticProperties3.js @@ -1,5 +1,4 @@ //// [classExpressionWithStaticProperties3.ts] - declare var console: any; const arr: {y(): number}[] = []; for (let i = 0; i < 3; i++) { diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols index 4c7750c12a7a0..cd7cbdba7bd0c 100644 --- a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols +++ b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols @@ -1,42 +1,41 @@ === tests/cases/compiler/classExpressionWithStaticProperties3.ts === - declare var console: any; ->console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 1, 11)) +>console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 0, 11)) const arr: {y(): number}[] = []; ->arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 2, 5)) ->y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 2, 12)) +>arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5)) +>y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 1, 12)) for (let i = 0; i < 3; i++) { ->i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 3, 8)) ->i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 3, 8)) ->i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 3, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 2, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 2, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 2, 8)) arr.push(class C { >arr.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 2, 5)) +>arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 4, 13)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 3, 13)) static x = i; ->x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 4, 22)) ->i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 3, 8)) +>x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 3, 22)) +>i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 2, 8)) static y = () => C.x * 2; ->y : Symbol(C.y, Decl(classExpressionWithStaticProperties3.ts, 5, 21)) ->C.x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 4, 22)) ->C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 4, 13)) ->x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 4, 22)) +>y : Symbol(C.y, Decl(classExpressionWithStaticProperties3.ts, 4, 21)) +>C.x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 3, 22)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 3, 13)) +>x : Symbol(C.x, Decl(classExpressionWithStaticProperties3.ts, 3, 22)) }); } arr.forEach(C => console.log(C.y())); >arr.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 2, 5)) +>arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5)) >forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 9, 12)) ->console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 1, 11)) ->C.y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 2, 12)) ->C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 9, 12)) ->y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 2, 12)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 8, 12)) +>console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 0, 11)) +>C.y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 1, 12)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 8, 12)) +>y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 1, 12)) diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.types b/tests/baselines/reference/classExpressionWithStaticProperties3.types index dbbb1f378a838..ff2871e4d9400 100644 --- a/tests/baselines/reference/classExpressionWithStaticProperties3.types +++ b/tests/baselines/reference/classExpressionWithStaticProperties3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/classExpressionWithStaticProperties3.ts === - declare var console: any; >console : any diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.js b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.js index 3993f18c0c741..0ac97e7a7553a 100644 --- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.js +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.js @@ -1,5 +1,4 @@ //// [classExpressionWithStaticPropertiesES63.ts] - declare var console: any; const arr: {y(): number}[] = []; for (let i = 0; i < 3; i++) { diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols index 94ea5cfaa8ca9..822dfaf81a097 100644 --- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols @@ -1,42 +1,41 @@ === tests/cases/compiler/classExpressionWithStaticPropertiesES63.ts === - declare var console: any; ->console : Symbol(console, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 11)) +>console : Symbol(console, Decl(classExpressionWithStaticPropertiesES63.ts, 0, 11)) const arr: {y(): number}[] = []; ->arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 5)) ->y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 12)) +>arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 5)) +>y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 12)) for (let i = 0; i < 3; i++) { ->i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 8)) ->i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 8)) ->i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 8)) +>i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 8)) arr.push(class C { >arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 5)) +>arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 5)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 13)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 13)) static x = i; ->x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 22)) ->i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 8)) +>x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 22)) +>i : Symbol(i, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 8)) static y = () => C.x * 2; ->y : Symbol(C.y, Decl(classExpressionWithStaticPropertiesES63.ts, 5, 21)) ->C.x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 22)) ->C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 13)) ->x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 22)) +>y : Symbol(C.y, Decl(classExpressionWithStaticPropertiesES63.ts, 4, 21)) +>C.x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 22)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 13)) +>x : Symbol(C.x, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 22)) }); } arr.forEach(C => console.log(C.y())); >arr.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 5)) +>arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 5)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 9, 12)) ->console : Symbol(console, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 11)) ->C.y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 12)) ->C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 9, 12)) ->y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 2, 12)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 8, 12)) +>console : Symbol(console, Decl(classExpressionWithStaticPropertiesES63.ts, 0, 11)) +>C.y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 12)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 8, 12)) +>y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 12)) diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types index b725df6fd74e8..da771990ee921 100644 --- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types @@ -1,5 +1,4 @@ === tests/cases/compiler/classExpressionWithStaticPropertiesES63.ts === - declare var console: any; >console : any diff --git a/tests/baselines/reference/classOrder2.errors.txt b/tests/baselines/reference/classOrder2.errors.txt index 59184e6a5e64f..ce6dd9bd50f0c 100644 --- a/tests/baselines/reference/classOrder2.errors.txt +++ b/tests/baselines/reference/classOrder2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/classOrder2.ts(2,17): error TS2449: Class 'B' used before its declaration. +tests/cases/compiler/classOrder2.ts(1,17): error TS2449: Class 'B' used before its declaration. ==== tests/cases/compiler/classOrder2.ts (1 errors) ==== - class A extends B { ~ !!! error TS2449: Class 'B' used before its declaration. diff --git a/tests/baselines/reference/classOrder2.js b/tests/baselines/reference/classOrder2.js index 897089b8b5789..13ddfd8ae8251 100644 --- a/tests/baselines/reference/classOrder2.js +++ b/tests/baselines/reference/classOrder2.js @@ -1,5 +1,4 @@ //// [classOrder2.ts] - class A extends B { foo() { this.bar(); } diff --git a/tests/baselines/reference/classStaticPropertyTypeGuard.js b/tests/baselines/reference/classStaticPropertyTypeGuard.js index 872f78db4c400..7b0a8fa0a79a7 100644 --- a/tests/baselines/reference/classStaticPropertyTypeGuard.js +++ b/tests/baselines/reference/classStaticPropertyTypeGuard.js @@ -1,5 +1,4 @@ //// [classStaticPropertyTypeGuard.ts] - // Repro from #8923 class A { diff --git a/tests/baselines/reference/classStaticPropertyTypeGuard.symbols b/tests/baselines/reference/classStaticPropertyTypeGuard.symbols index c4d2acd50b016..4823b85ccae80 100644 --- a/tests/baselines/reference/classStaticPropertyTypeGuard.symbols +++ b/tests/baselines/reference/classStaticPropertyTypeGuard.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/classStaticPropertyTypeGuard.ts === - // Repro from #8923 class A { >A : Symbol(A, Decl(classStaticPropertyTypeGuard.ts, 0, 0)) private static _a: string | undefined; ->_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) public get a(): string { ->a : Symbol(A.a, Decl(classStaticPropertyTypeGuard.ts, 4, 42)) +>a : Symbol(A.a, Decl(classStaticPropertyTypeGuard.ts, 3, 42)) if (A._a) { ->A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) >A : Symbol(A, Decl(classStaticPropertyTypeGuard.ts, 0, 0)) ->_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) return A._a; // is possibly null or undefined. ->A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) >A : Symbol(A, Decl(classStaticPropertyTypeGuard.ts, 0, 0)) ->_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) } return A._a = 'helloworld'; ->A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>A._a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) >A : Symbol(A, Decl(classStaticPropertyTypeGuard.ts, 0, 0)) ->_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 3, 9)) +>_a : Symbol(A._a, Decl(classStaticPropertyTypeGuard.ts, 2, 9)) } } diff --git a/tests/baselines/reference/classStaticPropertyTypeGuard.types b/tests/baselines/reference/classStaticPropertyTypeGuard.types index f9bf8b68062fd..b0b6bb4d3985c 100644 --- a/tests/baselines/reference/classStaticPropertyTypeGuard.types +++ b/tests/baselines/reference/classStaticPropertyTypeGuard.types @@ -1,5 +1,4 @@ === tests/cases/compiler/classStaticPropertyTypeGuard.ts === - // Repro from #8923 class A { diff --git a/tests/baselines/reference/classWithEmptyTypeParameter.errors.txt b/tests/baselines/reference/classWithEmptyTypeParameter.errors.txt new file mode 100644 index 0000000000000..8114bbd7ba03c --- /dev/null +++ b/tests/baselines/reference/classWithEmptyTypeParameter.errors.txt @@ -0,0 +1,8 @@ +tests/cases/compiler/classWithEmptyTypeParameter.ts(1,8): error TS1098: Type parameter list cannot be empty. + + +==== tests/cases/compiler/classWithEmptyTypeParameter.ts (1 errors) ==== + class C<> { + ~~ +!!! error TS1098: Type parameter list cannot be empty. + } \ No newline at end of file diff --git a/tests/baselines/reference/classWithEmptyTypeParameter.js b/tests/baselines/reference/classWithEmptyTypeParameter.js new file mode 100644 index 0000000000000..c25ace495b478 --- /dev/null +++ b/tests/baselines/reference/classWithEmptyTypeParameter.js @@ -0,0 +1,10 @@ +//// [classWithEmptyTypeParameter.ts] +class C<> { +} + +//// [classWithEmptyTypeParameter.js] +var C = (function () { + function C() { + } + return C; +}()); diff --git a/tests/baselines/reference/commaOperatorInvalidAssignmentType.errors.txt b/tests/baselines/reference/commaOperatorInvalidAssignmentType.errors.txt index a22fbb1e1d00e..ecf7e5ed1dc07 100644 --- a/tests/baselines/reference/commaOperatorInvalidAssignmentType.errors.txt +++ b/tests/baselines/reference/commaOperatorInvalidAssignmentType.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(11,1): error TS2322: Type 'string' is not assignable to type 'boolean'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(12,1): error TS2322: Type 'number' is not assignable to type 'boolean'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(14,1): error TS2322: Type 'boolean' is not assignable to type 'number'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(15,1): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(17,1): error TS2322: Type 'boolean' is not assignable to type 'string'. -tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(18,1): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(10,1): error TS2322: Type 'string' is not assignable to type 'boolean'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(11,1): error TS2322: Type 'number' is not assignable to type 'boolean'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(13,1): error TS2322: Type 'boolean' is not assignable to type 'number'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(14,1): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(16,1): error TS2322: Type 'boolean' is not assignable to type 'string'. +tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts(17,1): error TS2322: Type 'number' is not assignable to type 'string'. ==== tests/cases/conformance/expressions/commaOperator/commaOperatorInvalidAssignmentType.ts (6 errors) ==== - var BOOLEAN: boolean; var NUMBER: number; var STRING: string; diff --git a/tests/baselines/reference/commaOperatorInvalidAssignmentType.js b/tests/baselines/reference/commaOperatorInvalidAssignmentType.js index 9a16d4bbc282e..0d6b9389cfc78 100644 --- a/tests/baselines/reference/commaOperatorInvalidAssignmentType.js +++ b/tests/baselines/reference/commaOperatorInvalidAssignmentType.js @@ -1,5 +1,4 @@ //// [commaOperatorInvalidAssignmentType.ts] - var BOOLEAN: boolean; var NUMBER: number; var STRING: string; diff --git a/tests/baselines/reference/commaOperatorOtherInvalidOperation.errors.txt b/tests/baselines/reference/commaOperatorOtherInvalidOperation.errors.txt index a38fcd0741eeb..32e8464a19573 100644 --- a/tests/baselines/reference/commaOperatorOtherInvalidOperation.errors.txt +++ b/tests/baselines/reference/commaOperatorOtherInvalidOperation.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts(7,5): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts(13,9): error TS2322: Type 'T2' is not assignable to type 'T1'. +tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts(6,5): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts(12,9): error TS2322: Type 'T2' is not assignable to type 'T1'. ==== tests/cases/conformance/expressions/commaOperator/commaOperatorOtherInvalidOperation.ts (2 errors) ==== - //Expect to have compiler errors //Comma operator in fuction arguments and return function foo(x: number, y: string) { diff --git a/tests/baselines/reference/commaOperatorOtherInvalidOperation.js b/tests/baselines/reference/commaOperatorOtherInvalidOperation.js index 996b08e2ca064..d14dec677095c 100644 --- a/tests/baselines/reference/commaOperatorOtherInvalidOperation.js +++ b/tests/baselines/reference/commaOperatorOtherInvalidOperation.js @@ -1,5 +1,4 @@ //// [commaOperatorOtherInvalidOperation.ts] - //Expect to have compiler errors //Comma operator in fuction arguments and return function foo(x: number, y: string) { diff --git a/tests/baselines/reference/commaOperatorOtherValidOperation.js b/tests/baselines/reference/commaOperatorOtherValidOperation.js index 3a08735a2edfd..383b7c5058e33 100644 --- a/tests/baselines/reference/commaOperatorOtherValidOperation.js +++ b/tests/baselines/reference/commaOperatorOtherValidOperation.js @@ -1,5 +1,4 @@ //// [commaOperatorOtherValidOperation.ts] - //Comma operator in for loop for (var i = 0, j = 10; i < j; i++, j--) { diff --git a/tests/baselines/reference/commaOperatorOtherValidOperation.symbols b/tests/baselines/reference/commaOperatorOtherValidOperation.symbols index b0ff23dc11810..da65d20fc302d 100644 --- a/tests/baselines/reference/commaOperatorOtherValidOperation.symbols +++ b/tests/baselines/reference/commaOperatorOtherValidOperation.symbols @@ -1,51 +1,50 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorOtherValidOperation.ts === - //Comma operator in for loop for (var i = 0, j = 10; i < j; i++, j--) ->i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 2, 8)) ->j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 2, 15)) ->i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 2, 8)) ->j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 2, 15)) ->i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 2, 8)) ->j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 2, 15)) +>i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 1, 8)) +>j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 1, 15)) +>i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 1, 8)) +>j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 1, 15)) +>i : Symbol(i, Decl(commaOperatorOtherValidOperation.ts, 1, 8)) +>j : Symbol(j, Decl(commaOperatorOtherValidOperation.ts, 1, 15)) { } //Comma operator in fuction arguments and return function foo(x: number, y: string) ->foo : Symbol(foo, Decl(commaOperatorOtherValidOperation.ts, 4, 1)) ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 7, 13)) ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 7, 23)) +>foo : Symbol(foo, Decl(commaOperatorOtherValidOperation.ts, 3, 1)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 6, 13)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 6, 23)) { return x, y; ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 7, 13)) ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 7, 23)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 6, 13)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 6, 23)) } var resultIsString = foo(1, "123"); ->resultIsString : Symbol(resultIsString, Decl(commaOperatorOtherValidOperation.ts, 11, 3)) ->foo : Symbol(foo, Decl(commaOperatorOtherValidOperation.ts, 4, 1)) +>resultIsString : Symbol(resultIsString, Decl(commaOperatorOtherValidOperation.ts, 10, 3)) +>foo : Symbol(foo, Decl(commaOperatorOtherValidOperation.ts, 3, 1)) //TypeParameters function foo1() ->foo1 : Symbol(foo1, Decl(commaOperatorOtherValidOperation.ts, 11, 35)) ->T1 : Symbol(T1, Decl(commaOperatorOtherValidOperation.ts, 14, 14)) ->T2 : Symbol(T2, Decl(commaOperatorOtherValidOperation.ts, 14, 17)) +>foo1 : Symbol(foo1, Decl(commaOperatorOtherValidOperation.ts, 10, 35)) +>T1 : Symbol(T1, Decl(commaOperatorOtherValidOperation.ts, 13, 14)) +>T2 : Symbol(T2, Decl(commaOperatorOtherValidOperation.ts, 13, 17)) { var x: T1; ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) ->T1 : Symbol(T1, Decl(commaOperatorOtherValidOperation.ts, 14, 14)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 15, 7)) +>T1 : Symbol(T1, Decl(commaOperatorOtherValidOperation.ts, 13, 14)) var y: T2; ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 17, 7)) ->T2 : Symbol(T2, Decl(commaOperatorOtherValidOperation.ts, 14, 17)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) +>T2 : Symbol(T2, Decl(commaOperatorOtherValidOperation.ts, 13, 17)) x, y; ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 17, 7)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 15, 7)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) var resultIsT1 = (y, x); ->resultIsT1 : Symbol(resultIsT1, Decl(commaOperatorOtherValidOperation.ts, 19, 7)) ->y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 17, 7)) ->x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) +>resultIsT1 : Symbol(resultIsT1, Decl(commaOperatorOtherValidOperation.ts, 18, 7)) +>y : Symbol(y, Decl(commaOperatorOtherValidOperation.ts, 16, 7)) +>x : Symbol(x, Decl(commaOperatorOtherValidOperation.ts, 15, 7)) } diff --git a/tests/baselines/reference/commaOperatorOtherValidOperation.types b/tests/baselines/reference/commaOperatorOtherValidOperation.types index 2691a3384bd4e..71fc5853c9a51 100644 --- a/tests/baselines/reference/commaOperatorOtherValidOperation.types +++ b/tests/baselines/reference/commaOperatorOtherValidOperation.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorOtherValidOperation.ts === - //Comma operator in for loop for (var i = 0, j = 10; i < j; i++, j--) >i : number diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.js b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.js index d7b857f9f8f1e..522bbbe4e19d0 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandAnyType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols index ecd5a3932ba94..ba9618a5ecf08 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols @@ -1,78 +1,77 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandAnyType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //The second operand type is any ANY, ANY; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) BOOLEAN, ANY; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) NUMBER, ANY; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) STRING, ANY; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) OBJECT, ANY; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) //Return type is any var resultIsAny1 = (ANY, ANY); ->resultIsAny1 : Symbol(resultIsAny1, Decl(commaOperatorWithSecondOperandAnyType.ts, 15, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny1 : Symbol(resultIsAny1, Decl(commaOperatorWithSecondOperandAnyType.ts, 14, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny2 = (BOOLEAN, ANY); ->resultIsAny2 : Symbol(resultIsAny2, Decl(commaOperatorWithSecondOperandAnyType.ts, 16, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny2 : Symbol(resultIsAny2, Decl(commaOperatorWithSecondOperandAnyType.ts, 15, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny3 = (NUMBER, ANY); ->resultIsAny3 : Symbol(resultIsAny3, Decl(commaOperatorWithSecondOperandAnyType.ts, 17, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny3 : Symbol(resultIsAny3, Decl(commaOperatorWithSecondOperandAnyType.ts, 16, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny4 = (STRING, ANY); ->resultIsAny4 : Symbol(resultIsAny4, Decl(commaOperatorWithSecondOperandAnyType.ts, 18, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny4 : Symbol(resultIsAny4, Decl(commaOperatorWithSecondOperandAnyType.ts, 17, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny5 = (OBJECT, ANY); ->resultIsAny5 : Symbol(resultIsAny5, Decl(commaOperatorWithSecondOperandAnyType.ts, 19, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny5 : Symbol(resultIsAny5, Decl(commaOperatorWithSecondOperandAnyType.ts, 18, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) //Literal and expression var x: any; ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) 1, ANY; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) ++NUMBER, ANY; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) "string", [null, 1]; "string".charAt(0), [null, 1]; @@ -80,36 +79,36 @@ var x: any; >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) true, x("any"); ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) !BOOLEAN, x.doSomeThing(); ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) var resultIsAny6 = (1, ANY); ->resultIsAny6 : Symbol(resultIsAny6, Decl(commaOperatorWithSecondOperandAnyType.ts, 31, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny6 : Symbol(resultIsAny6, Decl(commaOperatorWithSecondOperandAnyType.ts, 30, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny7 = (++NUMBER, ANY); ->resultIsAny7 : Symbol(resultIsAny7, Decl(commaOperatorWithSecondOperandAnyType.ts, 32, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 3, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>resultIsAny7 : Symbol(resultIsAny7, Decl(commaOperatorWithSecondOperandAnyType.ts, 31, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandAnyType.ts, 0, 3)) var resultIsAny8 = ("string", null); ->resultIsAny8 : Symbol(resultIsAny8, Decl(commaOperatorWithSecondOperandAnyType.ts, 33, 3)) +>resultIsAny8 : Symbol(resultIsAny8, Decl(commaOperatorWithSecondOperandAnyType.ts, 32, 3)) var resultIsAny9 = ("string".charAt(0), undefined); ->resultIsAny9 : Symbol(resultIsAny9, Decl(commaOperatorWithSecondOperandAnyType.ts, 34, 3)) +>resultIsAny9 : Symbol(resultIsAny9, Decl(commaOperatorWithSecondOperandAnyType.ts, 33, 3)) >"string".charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >undefined : Symbol(undefined) var resultIsAny10 = (true, x("any")); ->resultIsAny10 : Symbol(resultIsAny10, Decl(commaOperatorWithSecondOperandAnyType.ts, 35, 3)) ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>resultIsAny10 : Symbol(resultIsAny10, Decl(commaOperatorWithSecondOperandAnyType.ts, 34, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) var resultIsAny11 = (!BOOLEAN, x.doSomeThing()); ->resultIsAny11 : Symbol(resultIsAny11, Decl(commaOperatorWithSecondOperandAnyType.ts, 36, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 2, 3)) ->x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 22, 3)) +>resultIsAny11 : Symbol(resultIsAny11, Decl(commaOperatorWithSecondOperandAnyType.ts, 35, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandAnyType.ts, 1, 3)) +>x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.types b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.types index b3695b74eeaad..e2535bd17abab 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandAnyType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.js b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.js index 92996fe679dee..dfaba1a93ca29 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandBooleanType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols index 2ea892ad16e23..9be885bf41c09 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols @@ -1,111 +1,110 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandBooleanType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //The second operand type is boolean ANY, BOOLEAN; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) BOOLEAN, BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) NUMBER, BOOLEAN; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) STRING, BOOLEAN; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) OBJECT, BOOLEAN; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) //Return type is boolean var resultIsBoolean1 = (ANY, BOOLEAN); ->resultIsBoolean1 : Symbol(resultIsBoolean1, Decl(commaOperatorWithSecondOperandBooleanType.ts, 15, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean1 : Symbol(resultIsBoolean1, Decl(commaOperatorWithSecondOperandBooleanType.ts, 14, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean2 = (BOOLEAN, BOOLEAN); ->resultIsBoolean2 : Symbol(resultIsBoolean2, Decl(commaOperatorWithSecondOperandBooleanType.ts, 16, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean2 : Symbol(resultIsBoolean2, Decl(commaOperatorWithSecondOperandBooleanType.ts, 15, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean3 = (NUMBER, BOOLEAN); ->resultIsBoolean3 : Symbol(resultIsBoolean3, Decl(commaOperatorWithSecondOperandBooleanType.ts, 17, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean3 : Symbol(resultIsBoolean3, Decl(commaOperatorWithSecondOperandBooleanType.ts, 16, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean4 = (STRING, BOOLEAN); ->resultIsBoolean4 : Symbol(resultIsBoolean4, Decl(commaOperatorWithSecondOperandBooleanType.ts, 18, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean4 : Symbol(resultIsBoolean4, Decl(commaOperatorWithSecondOperandBooleanType.ts, 17, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean5 = (OBJECT, BOOLEAN); ->resultIsBoolean5 : Symbol(resultIsBoolean5, Decl(commaOperatorWithSecondOperandBooleanType.ts, 19, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean5 : Symbol(resultIsBoolean5, Decl(commaOperatorWithSecondOperandBooleanType.ts, 18, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) //Literal and expression null, BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) ANY = undefined, BOOLEAN; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) >undefined : Symbol(undefined) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) 1, true; ++NUMBER, true; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) [1, 2, 3], !BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) OBJECT = [1, 2, 3], BOOLEAN = false; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean6 = (null, BOOLEAN); ->resultIsBoolean6 : Symbol(resultIsBoolean6, Decl(commaOperatorWithSecondOperandBooleanType.ts, 29, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean6 : Symbol(resultIsBoolean6, Decl(commaOperatorWithSecondOperandBooleanType.ts, 28, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean7 = (ANY = undefined, BOOLEAN); ->resultIsBoolean7 : Symbol(resultIsBoolean7, Decl(commaOperatorWithSecondOperandBooleanType.ts, 30, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) +>resultIsBoolean7 : Symbol(resultIsBoolean7, Decl(commaOperatorWithSecondOperandBooleanType.ts, 29, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandBooleanType.ts, 0, 3)) >undefined : Symbol(undefined) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean8 = (1, true); ->resultIsBoolean8 : Symbol(resultIsBoolean8, Decl(commaOperatorWithSecondOperandBooleanType.ts, 31, 3)) +>resultIsBoolean8 : Symbol(resultIsBoolean8, Decl(commaOperatorWithSecondOperandBooleanType.ts, 30, 3)) var resultIsBoolean9 = (++NUMBER, true); ->resultIsBoolean9 : Symbol(resultIsBoolean9, Decl(commaOperatorWithSecondOperandBooleanType.ts, 32, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 3, 3)) +>resultIsBoolean9 : Symbol(resultIsBoolean9, Decl(commaOperatorWithSecondOperandBooleanType.ts, 31, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) var resultIsBoolean10 = ([1, 2, 3], !BOOLEAN); ->resultIsBoolean10 : Symbol(resultIsBoolean10, Decl(commaOperatorWithSecondOperandBooleanType.ts, 33, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean10 : Symbol(resultIsBoolean10, Decl(commaOperatorWithSecondOperandBooleanType.ts, 32, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) var resultIsBoolean11 = (OBJECT = [1, 2, 3], BOOLEAN = false); ->resultIsBoolean11 : Symbol(resultIsBoolean11, Decl(commaOperatorWithSecondOperandBooleanType.ts, 34, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 5, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 2, 3)) +>resultIsBoolean11 : Symbol(resultIsBoolean11, Decl(commaOperatorWithSecondOperandBooleanType.ts, 33, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandBooleanType.ts, 1, 3)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types index 64167f22e6cf0..6c791bdee2c57 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandBooleanType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.js b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.js index 45d38c9c9c500..b5b8887e749f0 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandNumberType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols index 3e6fdfd9ef83e..bf5ff9437a3ee 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols @@ -1,115 +1,114 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandNumberType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //The second operand type is number ANY, NUMBER; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) BOOLEAN, NUMBER; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) NUMBER, NUMBER; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) STRING, NUMBER; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) OBJECT, NUMBER; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 5, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) //Return type is number var resultIsNumber1 = (ANY, NUMBER); ->resultIsNumber1 : Symbol(resultIsNumber1, Decl(commaOperatorWithSecondOperandNumberType.ts, 15, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber1 : Symbol(resultIsNumber1, Decl(commaOperatorWithSecondOperandNumberType.ts, 14, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber2 = (BOOLEAN, NUMBER); ->resultIsNumber2 : Symbol(resultIsNumber2, Decl(commaOperatorWithSecondOperandNumberType.ts, 16, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber2 : Symbol(resultIsNumber2, Decl(commaOperatorWithSecondOperandNumberType.ts, 15, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber3 = (NUMBER, NUMBER); ->resultIsNumber3 : Symbol(resultIsNumber3, Decl(commaOperatorWithSecondOperandNumberType.ts, 17, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber3 : Symbol(resultIsNumber3, Decl(commaOperatorWithSecondOperandNumberType.ts, 16, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber4 = (STRING, NUMBER); ->resultIsNumber4 : Symbol(resultIsNumber4, Decl(commaOperatorWithSecondOperandNumberType.ts, 18, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber4 : Symbol(resultIsNumber4, Decl(commaOperatorWithSecondOperandNumberType.ts, 17, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber5 = (OBJECT, NUMBER); ->resultIsNumber5 : Symbol(resultIsNumber5, Decl(commaOperatorWithSecondOperandNumberType.ts, 19, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 5, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber5 : Symbol(resultIsNumber5, Decl(commaOperatorWithSecondOperandNumberType.ts, 18, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) //Literal and expression null, NUMBER; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) ANY = undefined, NUMBER; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) >undefined : Symbol(undefined) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) true, 1; BOOLEAN = false, 1; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) "", NUMBER = 1; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) STRING.trim(), NUMBER = 1; >STRING.trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) >trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber6 = (null, NUMBER); ->resultIsNumber6 : Symbol(resultIsNumber6, Decl(commaOperatorWithSecondOperandNumberType.ts, 29, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber6 : Symbol(resultIsNumber6, Decl(commaOperatorWithSecondOperandNumberType.ts, 28, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber7 = (ANY = undefined, NUMBER); ->resultIsNumber7 : Symbol(resultIsNumber7, Decl(commaOperatorWithSecondOperandNumberType.ts, 30, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) +>resultIsNumber7 : Symbol(resultIsNumber7, Decl(commaOperatorWithSecondOperandNumberType.ts, 29, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandNumberType.ts, 0, 3)) >undefined : Symbol(undefined) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber8 = (true, 1); ->resultIsNumber8 : Symbol(resultIsNumber8, Decl(commaOperatorWithSecondOperandNumberType.ts, 31, 3)) +>resultIsNumber8 : Symbol(resultIsNumber8, Decl(commaOperatorWithSecondOperandNumberType.ts, 30, 3)) var resultIsNumber9 = (BOOLEAN = false, 1); ->resultIsNumber9 : Symbol(resultIsNumber9, Decl(commaOperatorWithSecondOperandNumberType.ts, 32, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) +>resultIsNumber9 : Symbol(resultIsNumber9, Decl(commaOperatorWithSecondOperandNumberType.ts, 31, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandNumberType.ts, 1, 3)) var resultIsNumber10 = ("", NUMBER = 1); ->resultIsNumber10 : Symbol(resultIsNumber10, Decl(commaOperatorWithSecondOperandNumberType.ts, 33, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>resultIsNumber10 : Symbol(resultIsNumber10, Decl(commaOperatorWithSecondOperandNumberType.ts, 32, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber11 = (STRING.trim(), NUMBER = 1); ->resultIsNumber11 : Symbol(resultIsNumber11, Decl(commaOperatorWithSecondOperandNumberType.ts, 34, 3)) +>resultIsNumber11 : Symbol(resultIsNumber11, Decl(commaOperatorWithSecondOperandNumberType.ts, 33, 3)) >STRING.trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) >trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types index 8727665c59b2a..2a53a23c4e0fa 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandNumberType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.js b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.js index dd269d8821788..ef8148639343c 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandObjectType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols index cfaab330b4651..6df267080783d 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols @@ -1,122 +1,121 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandObjectType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class CLASS { ->CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 19)) +>CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19)) num: number; ->num : Symbol(CLASS.num, Decl(commaOperatorWithSecondOperandObjectType.ts, 7, 13)) +>num : Symbol(CLASS.num, Decl(commaOperatorWithSecondOperandObjectType.ts, 6, 13)) } //The second operand type is Object ANY, OBJECT; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) BOOLEAN, OBJECT; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) NUMBER, OBJECT; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) STRING, OBJECT; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) OBJECT, OBJECT; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) //Return type is Object var resultIsObject1 = (ANY, OBJECT); ->resultIsObject1 : Symbol(resultIsObject1, Decl(commaOperatorWithSecondOperandObjectType.ts, 19, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject1 : Symbol(resultIsObject1, Decl(commaOperatorWithSecondOperandObjectType.ts, 18, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject2 = (BOOLEAN, OBJECT); ->resultIsObject2 : Symbol(resultIsObject2, Decl(commaOperatorWithSecondOperandObjectType.ts, 20, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject2 : Symbol(resultIsObject2, Decl(commaOperatorWithSecondOperandObjectType.ts, 19, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject3 = (NUMBER, OBJECT); ->resultIsObject3 : Symbol(resultIsObject3, Decl(commaOperatorWithSecondOperandObjectType.ts, 21, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject3 : Symbol(resultIsObject3, Decl(commaOperatorWithSecondOperandObjectType.ts, 20, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject4 = (STRING, OBJECT); ->resultIsObject4 : Symbol(resultIsObject4, Decl(commaOperatorWithSecondOperandObjectType.ts, 22, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject4 : Symbol(resultIsObject4, Decl(commaOperatorWithSecondOperandObjectType.ts, 21, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject5 = (OBJECT, OBJECT); ->resultIsObject5 : Symbol(resultIsObject5, Decl(commaOperatorWithSecondOperandObjectType.ts, 23, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject5 : Symbol(resultIsObject5, Decl(commaOperatorWithSecondOperandObjectType.ts, 22, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) //Literal and expression null, OBJECT ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) ANY = null, OBJECT ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) true, {} !BOOLEAN, [] ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) "string", new Date() >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) STRING.toLowerCase(), new CLASS() >STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 19)) +>CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19)) var resultIsObject6 = (null, OBJECT); ->resultIsObject6 : Symbol(resultIsObject6, Decl(commaOperatorWithSecondOperandObjectType.ts, 33, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject6 : Symbol(resultIsObject6, Decl(commaOperatorWithSecondOperandObjectType.ts, 32, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject7 = (ANY = null, OBJECT); ->resultIsObject7 : Symbol(resultIsObject7, Decl(commaOperatorWithSecondOperandObjectType.ts, 34, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 3)) +>resultIsObject7 : Symbol(resultIsObject7, Decl(commaOperatorWithSecondOperandObjectType.ts, 33, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandObjectType.ts, 0, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) var resultIsObject8 = (true, {}); ->resultIsObject8 : Symbol(resultIsObject8, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 3)) +>resultIsObject8 : Symbol(resultIsObject8, Decl(commaOperatorWithSecondOperandObjectType.ts, 34, 3)) var resultIsObject9 = (!BOOLEAN, { a: 1, b: "s" }); ->resultIsObject9 : Symbol(resultIsObject9, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 2, 3)) ->a : Symbol(a, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 34)) ->b : Symbol(b, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 40)) +>resultIsObject9 : Symbol(resultIsObject9, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) +>a : Symbol(a, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 34)) +>b : Symbol(b, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 40)) var resultIsObject10 = ("string", new Date()); ->resultIsObject10 : Symbol(resultIsObject10, Decl(commaOperatorWithSecondOperandObjectType.ts, 37, 3)) +>resultIsObject10 : Symbol(resultIsObject10, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 3)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var resultIsObject11 = (STRING.toLowerCase(), new CLASS()); ->resultIsObject11 : Symbol(resultIsObject11, Decl(commaOperatorWithSecondOperandObjectType.ts, 38, 3)) +>resultIsObject11 : Symbol(resultIsObject11, Decl(commaOperatorWithSecondOperandObjectType.ts, 37, 3)) >STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 5, 19)) +>CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.types b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.types index 493d97d645471..15d9f074da58a 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandObjectType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.js b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.js index f3f19563817c5..412e9e8312106 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.js +++ b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.js @@ -1,5 +1,4 @@ //// [commaOperatorWithSecondOperandStringType.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols index d4f5873f4938b..2d9fc665a810b 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols @@ -1,121 +1,120 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandStringType.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var resultIsString: string; ->resultIsString : Symbol(resultIsString, Decl(commaOperatorWithSecondOperandStringType.ts, 7, 3)) +>resultIsString : Symbol(resultIsString, Decl(commaOperatorWithSecondOperandStringType.ts, 6, 3)) //The second operand is string ANY, STRING; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) BOOLEAN, STRING; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) NUMBER, STRING; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) STRING, STRING; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) OBJECT, STRING; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 5, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) //Return type is string var resultIsString1 = (ANY, STRING); ->resultIsString1 : Symbol(resultIsString1, Decl(commaOperatorWithSecondOperandStringType.ts, 17, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString1 : Symbol(resultIsString1, Decl(commaOperatorWithSecondOperandStringType.ts, 16, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString2 = (BOOLEAN, STRING); ->resultIsString2 : Symbol(resultIsString2, Decl(commaOperatorWithSecondOperandStringType.ts, 18, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString2 : Symbol(resultIsString2, Decl(commaOperatorWithSecondOperandStringType.ts, 17, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString3 = (NUMBER, STRING); ->resultIsString3 : Symbol(resultIsString3, Decl(commaOperatorWithSecondOperandStringType.ts, 19, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString3 : Symbol(resultIsString3, Decl(commaOperatorWithSecondOperandStringType.ts, 18, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString4 = (STRING, STRING); ->resultIsString4 : Symbol(resultIsString4, Decl(commaOperatorWithSecondOperandStringType.ts, 20, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString4 : Symbol(resultIsString4, Decl(commaOperatorWithSecondOperandStringType.ts, 19, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString5 = (OBJECT, STRING); ->resultIsString5 : Symbol(resultIsString5, Decl(commaOperatorWithSecondOperandStringType.ts, 21, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 5, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString5 : Symbol(resultIsString5, Decl(commaOperatorWithSecondOperandStringType.ts, 20, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) //Literal and expression null, STRING; ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) ANY = new Date(), STRING; ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) true, ""; BOOLEAN == undefined, ""; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) >undefined : Symbol(undefined) ["a", "b"], NUMBER.toString(); >NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) OBJECT = new Object, STRING + "string"; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString6 = (null, STRING); ->resultIsString6 : Symbol(resultIsString6, Decl(commaOperatorWithSecondOperandStringType.ts, 31, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>resultIsString6 : Symbol(resultIsString6, Decl(commaOperatorWithSecondOperandStringType.ts, 30, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString7 = (ANY = new Date(), STRING); ->resultIsString7 : Symbol(resultIsString7, Decl(commaOperatorWithSecondOperandStringType.ts, 32, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) +>resultIsString7 : Symbol(resultIsString7, Decl(commaOperatorWithSecondOperandStringType.ts, 31, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString8 = (true, ""); ->resultIsString8 : Symbol(resultIsString8, Decl(commaOperatorWithSecondOperandStringType.ts, 33, 3)) +>resultIsString8 : Symbol(resultIsString8, Decl(commaOperatorWithSecondOperandStringType.ts, 32, 3)) var resultIsString9 = (BOOLEAN == undefined, ""); ->resultIsString9 : Symbol(resultIsString9, Decl(commaOperatorWithSecondOperandStringType.ts, 34, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) +>resultIsString9 : Symbol(resultIsString9, Decl(commaOperatorWithSecondOperandStringType.ts, 33, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandStringType.ts, 1, 3)) >undefined : Symbol(undefined) var resultIsString10 = (["a", "b"], NUMBER.toString()); ->resultIsString10 : Symbol(resultIsString10, Decl(commaOperatorWithSecondOperandStringType.ts, 35, 3)) +>resultIsString10 : Symbol(resultIsString10, Decl(commaOperatorWithSecondOperandStringType.ts, 34, 3)) >NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) var resultIsString11 = (new Object, STRING + "string"); ->resultIsString11 : Symbol(resultIsString11, Decl(commaOperatorWithSecondOperandStringType.ts, 36, 3)) +>resultIsString11 : Symbol(resultIsString11, Decl(commaOperatorWithSecondOperandStringType.ts, 35, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.types b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.types index af5b7d2cb06d4..ca0cb47536283 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.types +++ b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorWithSecondOperandStringType.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commaOperatorsMultipleOperators.js b/tests/baselines/reference/commaOperatorsMultipleOperators.js index 5157eb2c8ffcf..15d93c1f18c39 100644 --- a/tests/baselines/reference/commaOperatorsMultipleOperators.js +++ b/tests/baselines/reference/commaOperatorsMultipleOperators.js @@ -1,5 +1,4 @@ //// [commaOperatorsMultipleOperators.ts] - var ANY: any; var BOOLEAN: boolean; var NUMBER: number; diff --git a/tests/baselines/reference/commaOperatorsMultipleOperators.symbols b/tests/baselines/reference/commaOperatorsMultipleOperators.symbols index bc1953709c27a..3a580bc49e963 100644 --- a/tests/baselines/reference/commaOperatorsMultipleOperators.symbols +++ b/tests/baselines/reference/commaOperatorsMultipleOperators.symbols @@ -1,95 +1,94 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorsMultipleOperators.ts === - var ANY: any; ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) var NUMBER: number; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) var STRING: string; ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) var OBJECT: Object; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //Expected: work well ANY, BOOLEAN, NUMBER; ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) BOOLEAN, NUMBER, STRING; ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) NUMBER, STRING, OBJECT; ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) STRING, OBJECT, ANY; ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) OBJECT, ANY, BOOLEAN; ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) //Results should have the same type as the third operand var resultIsAny1 = (STRING, OBJECT, ANY); ->resultIsAny1 : Symbol(resultIsAny1, Decl(commaOperatorsMultipleOperators.ts, 15, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>resultIsAny1 : Symbol(resultIsAny1, Decl(commaOperatorsMultipleOperators.ts, 14, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) var resultIsBoolean1 = (OBJECT, ANY, BOOLEAN); ->resultIsBoolean1 : Symbol(resultIsBoolean1, Decl(commaOperatorsMultipleOperators.ts, 16, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>resultIsBoolean1 : Symbol(resultIsBoolean1, Decl(commaOperatorsMultipleOperators.ts, 15, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) var resultIsNumber1 = (ANY, BOOLEAN, NUMBER); ->resultIsNumber1 : Symbol(resultIsNumber1, Decl(commaOperatorsMultipleOperators.ts, 17, 3)) ->ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>resultIsNumber1 : Symbol(resultIsNumber1, Decl(commaOperatorsMultipleOperators.ts, 16, 3)) +>ANY : Symbol(ANY, Decl(commaOperatorsMultipleOperators.ts, 0, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) var resultIsString1 = (BOOLEAN, NUMBER, STRING); ->resultIsString1 : Symbol(resultIsString1, Decl(commaOperatorsMultipleOperators.ts, 18, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>resultIsString1 : Symbol(resultIsString1, Decl(commaOperatorsMultipleOperators.ts, 17, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorsMultipleOperators.ts, 1, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) var resultIsObject1 = (NUMBER, STRING, OBJECT); ->resultIsObject1 : Symbol(resultIsObject1, Decl(commaOperatorsMultipleOperators.ts, 19, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) ->OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 5, 3)) +>resultIsObject1 : Symbol(resultIsObject1, Decl(commaOperatorsMultipleOperators.ts, 18, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) //Literal and expression null, true, 1; ++NUMBER, STRING.charAt(0), new Object(); ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) >STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var resultIsNumber2 = (null, true, 1); ->resultIsNumber2 : Symbol(resultIsNumber2, Decl(commaOperatorsMultipleOperators.ts, 25, 3)) +>resultIsNumber2 : Symbol(resultIsNumber2, Decl(commaOperatorsMultipleOperators.ts, 24, 3)) var resultIsObject2 = (++NUMBER, STRING.charAt(0), new Object()); ->resultIsObject2 : Symbol(resultIsObject2, Decl(commaOperatorsMultipleOperators.ts, 26, 3)) ->NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) +>resultIsObject2 : Symbol(resultIsObject2, Decl(commaOperatorsMultipleOperators.ts, 25, 3)) +>NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) >STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) ->STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) +>STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) >charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/commaOperatorsMultipleOperators.types b/tests/baselines/reference/commaOperatorsMultipleOperators.types index a0d5b382c59d3..99796e36cb714 100644 --- a/tests/baselines/reference/commaOperatorsMultipleOperators.types +++ b/tests/baselines/reference/commaOperatorsMultipleOperators.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/commaOperator/commaOperatorsMultipleOperators.ts === - var ANY: any; >ANY : any diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.js b/tests/baselines/reference/commentEmitAtEndOfFile1.js index cada7754002a7..1be031fa84af6 100644 --- a/tests/baselines/reference/commentEmitAtEndOfFile1.js +++ b/tests/baselines/reference/commentEmitAtEndOfFile1.js @@ -1,5 +1,4 @@ //// [commentEmitAtEndOfFile1.ts] - // test var f = '' // test #2 diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols b/tests/baselines/reference/commentEmitAtEndOfFile1.symbols index cb06d088307c7..1fc0ad0955348 100644 --- a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols +++ b/tests/baselines/reference/commentEmitAtEndOfFile1.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/commentEmitAtEndOfFile1.ts === - // test var f = '' ->f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 2, 3)) +>f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 1, 3)) // test #2 module foo { ->foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 2, 10)) +>foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 1, 10)) function bar() { } ->bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 4, 12)) +>bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 3, 12)) } // test #3 module empty { ->empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 6, 1)) +>empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 5, 1)) } // test #4 diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.types b/tests/baselines/reference/commentEmitAtEndOfFile1.types index 2071e98af8d8f..e6bd6b162fef3 100644 --- a/tests/baselines/reference/commentEmitAtEndOfFile1.types +++ b/tests/baselines/reference/commentEmitAtEndOfFile1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentEmitAtEndOfFile1.ts === - // test var f = '' >f : string diff --git a/tests/baselines/reference/commentOnExpressionStatement1.js b/tests/baselines/reference/commentOnExpressionStatement1.js index 713c079bcf201..9a15ab94bff4a 100644 --- a/tests/baselines/reference/commentOnExpressionStatement1.js +++ b/tests/baselines/reference/commentOnExpressionStatement1.js @@ -1,5 +1,4 @@ //// [commentOnExpressionStatement1.ts] - 1 + 1; // Comment. //// [commentOnExpressionStatement1.js] diff --git a/tests/baselines/reference/commentOnExpressionStatement1.symbols b/tests/baselines/reference/commentOnExpressionStatement1.symbols index f78660f0344dd..58d45470ca5c9 100644 --- a/tests/baselines/reference/commentOnExpressionStatement1.symbols +++ b/tests/baselines/reference/commentOnExpressionStatement1.symbols @@ -1,4 +1,3 @@ === tests/cases/compiler/commentOnExpressionStatement1.ts === - -No type information for this code.1 + 1; // Comment. +1 + 1; // Comment. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/commentOnExpressionStatement1.types b/tests/baselines/reference/commentOnExpressionStatement1.types index 39141c8d52e71..9eb15e394cab3 100644 --- a/tests/baselines/reference/commentOnExpressionStatement1.types +++ b/tests/baselines/reference/commentOnExpressionStatement1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentOnExpressionStatement1.ts === - 1 + 1; // Comment. >1 + 1 : number >1 : 1 diff --git a/tests/baselines/reference/commentOnIfStatement1.js b/tests/baselines/reference/commentOnIfStatement1.js index 521bc6ff1bea5..cad61e5ce3a2d 100644 --- a/tests/baselines/reference/commentOnIfStatement1.js +++ b/tests/baselines/reference/commentOnIfStatement1.js @@ -1,5 +1,4 @@ //// [commentOnIfStatement1.ts] - // Test if (true) { } diff --git a/tests/baselines/reference/commentOnIfStatement1.symbols b/tests/baselines/reference/commentOnIfStatement1.symbols index 03f357c8ccf5c..cc1fa728c4a1a 100644 --- a/tests/baselines/reference/commentOnIfStatement1.symbols +++ b/tests/baselines/reference/commentOnIfStatement1.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/commentOnIfStatement1.ts === - -No type information for this code.// Test +// Test No type information for this code.if (true) { No type information for this code.} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/commentOnIfStatement1.types b/tests/baselines/reference/commentOnIfStatement1.types index 4f7fcdddd22a3..c1bdee6af70a3 100644 --- a/tests/baselines/reference/commentOnIfStatement1.types +++ b/tests/baselines/reference/commentOnIfStatement1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentOnIfStatement1.ts === - // Test if (true) { >true : true diff --git a/tests/baselines/reference/commentOnImportStatement3.js b/tests/baselines/reference/commentOnImportStatement3.js index c33088408e84f..decc7a7878e72 100644 --- a/tests/baselines/reference/commentOnImportStatement3.js +++ b/tests/baselines/reference/commentOnImportStatement3.js @@ -5,6 +5,6 @@ import foo = require('./foo'); //// [commentOnImportStatement3.js] -/* copyright */ "use strict"; +/* copyright */ exports.__esModule = true; diff --git a/tests/baselines/reference/commentsAtEndOfFile1.js b/tests/baselines/reference/commentsAtEndOfFile1.js index d93dded59b062..2d4dae39e6ba3 100644 --- a/tests/baselines/reference/commentsAtEndOfFile1.js +++ b/tests/baselines/reference/commentsAtEndOfFile1.js @@ -1,5 +1,4 @@ //// [commentsAtEndOfFile1.ts] - Input: ; //Testing two diff --git a/tests/baselines/reference/commentsAtEndOfFile1.symbols b/tests/baselines/reference/commentsAtEndOfFile1.symbols index d35b4f251f6ab..c09a435f1a7fe 100644 --- a/tests/baselines/reference/commentsAtEndOfFile1.symbols +++ b/tests/baselines/reference/commentsAtEndOfFile1.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/commentsAtEndOfFile1.ts === - -No type information for this code.Input: +Input: No type information for this code.; No type information for this code.//Testing two No type information for this code. diff --git a/tests/baselines/reference/commentsAtEndOfFile1.types b/tests/baselines/reference/commentsAtEndOfFile1.types index 71eb367738b1a..6bac675706143 100644 --- a/tests/baselines/reference/commentsAtEndOfFile1.types +++ b/tests/baselines/reference/commentsAtEndOfFile1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsAtEndOfFile1.ts === - Input: >Input : any diff --git a/tests/baselines/reference/commentsClass.js b/tests/baselines/reference/commentsClass.js index 574fc0252278a..49fda992b0818 100644 --- a/tests/baselines/reference/commentsClass.js +++ b/tests/baselines/reference/commentsClass.js @@ -1,5 +1,4 @@ //// [commentsClass.ts] - /** This is class c2 without constuctor*/ class c2 { } // trailing comment1 diff --git a/tests/baselines/reference/commentsClass.symbols b/tests/baselines/reference/commentsClass.symbols index 9364dc50b02a9..901cca58d0edb 100644 --- a/tests/baselines/reference/commentsClass.symbols +++ b/tests/baselines/reference/commentsClass.symbols @@ -1,112 +1,111 @@ === tests/cases/compiler/commentsClass.ts === - /** This is class c2 without constuctor*/ class c2 { >c2 : Symbol(c2, Decl(commentsClass.ts, 0, 0)) } // trailing comment1 var i2 = new c2(); ->i2 : Symbol(i2, Decl(commentsClass.ts, 4, 3)) +>i2 : Symbol(i2, Decl(commentsClass.ts, 3, 3)) >c2 : Symbol(c2, Decl(commentsClass.ts, 0, 0)) var i2_c = c2; ->i2_c : Symbol(i2_c, Decl(commentsClass.ts, 5, 3)) +>i2_c : Symbol(i2_c, Decl(commentsClass.ts, 4, 3)) >c2 : Symbol(c2, Decl(commentsClass.ts, 0, 0)) class c3 { ->c3 : Symbol(c3, Decl(commentsClass.ts, 5, 14)) +>c3 : Symbol(c3, Decl(commentsClass.ts, 4, 14)) /** Constructor comment*/ constructor() { } // trailing comment of constructor } /* trailing comment 2 */ var i3 = new c3(); ->i3 : Symbol(i3, Decl(commentsClass.ts, 11, 3)) ->c3 : Symbol(c3, Decl(commentsClass.ts, 5, 14)) +>i3 : Symbol(i3, Decl(commentsClass.ts, 10, 3)) +>c3 : Symbol(c3, Decl(commentsClass.ts, 4, 14)) var i3_c = c3; ->i3_c : Symbol(i3_c, Decl(commentsClass.ts, 12, 3)) ->c3 : Symbol(c3, Decl(commentsClass.ts, 5, 14)) +>i3_c : Symbol(i3_c, Decl(commentsClass.ts, 11, 3)) +>c3 : Symbol(c3, Decl(commentsClass.ts, 4, 14)) /** Class comment*/ class c4 { ->c4 : Symbol(c4, Decl(commentsClass.ts, 12, 14)) +>c4 : Symbol(c4, Decl(commentsClass.ts, 11, 14)) /** Constructor comment*/ constructor() { } /* trailing comment of constructor 2*/ } var i4 = new c4(); ->i4 : Symbol(i4, Decl(commentsClass.ts, 19, 3)) ->c4 : Symbol(c4, Decl(commentsClass.ts, 12, 14)) +>i4 : Symbol(i4, Decl(commentsClass.ts, 18, 3)) +>c4 : Symbol(c4, Decl(commentsClass.ts, 11, 14)) var i4_c = c4; ->i4_c : Symbol(i4_c, Decl(commentsClass.ts, 20, 3)) ->c4 : Symbol(c4, Decl(commentsClass.ts, 12, 14)) +>i4_c : Symbol(i4_c, Decl(commentsClass.ts, 19, 3)) +>c4 : Symbol(c4, Decl(commentsClass.ts, 11, 14)) /** Class with statics*/ class c5 { ->c5 : Symbol(c5, Decl(commentsClass.ts, 20, 14)) +>c5 : Symbol(c5, Decl(commentsClass.ts, 19, 14)) static s1: number; ->s1 : Symbol(c5.s1, Decl(commentsClass.ts, 22, 10)) +>s1 : Symbol(c5.s1, Decl(commentsClass.ts, 21, 10)) } var i5 = new c5(); ->i5 : Symbol(i5, Decl(commentsClass.ts, 25, 3)) ->c5 : Symbol(c5, Decl(commentsClass.ts, 20, 14)) +>i5 : Symbol(i5, Decl(commentsClass.ts, 24, 3)) +>c5 : Symbol(c5, Decl(commentsClass.ts, 19, 14)) var i5_c = c5; ->i5_c : Symbol(i5_c, Decl(commentsClass.ts, 26, 3)) ->c5 : Symbol(c5, Decl(commentsClass.ts, 20, 14)) +>i5_c : Symbol(i5_c, Decl(commentsClass.ts, 25, 3)) +>c5 : Symbol(c5, Decl(commentsClass.ts, 19, 14)) /// class with statics and constructor class c6 { /// class with statics and constructor2 ->c6 : Symbol(c6, Decl(commentsClass.ts, 26, 14)) +>c6 : Symbol(c6, Decl(commentsClass.ts, 25, 14)) /// s1 comment static s1: number; /// s1 comment2 ->s1 : Symbol(c6.s1, Decl(commentsClass.ts, 29, 10)) +>s1 : Symbol(c6.s1, Decl(commentsClass.ts, 28, 10)) /// constructor comment constructor() { /// constructor comment2 } } var i6 = new c6(); ->i6 : Symbol(i6, Decl(commentsClass.ts, 36, 3)) ->c6 : Symbol(c6, Decl(commentsClass.ts, 26, 14)) +>i6 : Symbol(i6, Decl(commentsClass.ts, 35, 3)) +>c6 : Symbol(c6, Decl(commentsClass.ts, 25, 14)) var i6_c = c6; ->i6_c : Symbol(i6_c, Decl(commentsClass.ts, 37, 3)) ->c6 : Symbol(c6, Decl(commentsClass.ts, 26, 14)) +>i6_c : Symbol(i6_c, Decl(commentsClass.ts, 36, 3)) +>c6 : Symbol(c6, Decl(commentsClass.ts, 25, 14)) // class with statics and constructor class c7 { ->c7 : Symbol(c7, Decl(commentsClass.ts, 37, 14)) +>c7 : Symbol(c7, Decl(commentsClass.ts, 36, 14)) // s1 comment static s1: number; ->s1 : Symbol(c7.s1, Decl(commentsClass.ts, 40, 10)) +>s1 : Symbol(c7.s1, Decl(commentsClass.ts, 39, 10)) // constructor comment constructor() { } } var i7 = new c7(); ->i7 : Symbol(i7, Decl(commentsClass.ts, 47, 3)) ->c7 : Symbol(c7, Decl(commentsClass.ts, 37, 14)) +>i7 : Symbol(i7, Decl(commentsClass.ts, 46, 3)) +>c7 : Symbol(c7, Decl(commentsClass.ts, 36, 14)) var i7_c = c7; ->i7_c : Symbol(i7_c, Decl(commentsClass.ts, 48, 3)) ->c7 : Symbol(c7, Decl(commentsClass.ts, 37, 14)) +>i7_c : Symbol(i7_c, Decl(commentsClass.ts, 47, 3)) +>c7 : Symbol(c7, Decl(commentsClass.ts, 36, 14)) /** class with statics and constructor */ class c8 { ->c8 : Symbol(c8, Decl(commentsClass.ts, 48, 14)) +>c8 : Symbol(c8, Decl(commentsClass.ts, 47, 14)) /** s1 comment */ static s1: number; /** s1 comment2 */ ->s1 : Symbol(c8.s1, Decl(commentsClass.ts, 52, 10)) +>s1 : Symbol(c8.s1, Decl(commentsClass.ts, 51, 10)) /** constructor comment */ @@ -116,15 +115,15 @@ class c8 { } } var i8 = new c8(); ->i8 : Symbol(i8, Decl(commentsClass.ts, 62, 3)) ->c8 : Symbol(c8, Decl(commentsClass.ts, 48, 14)) +>i8 : Symbol(i8, Decl(commentsClass.ts, 61, 3)) +>c8 : Symbol(c8, Decl(commentsClass.ts, 47, 14)) var i8_c = c8; ->i8_c : Symbol(i8_c, Decl(commentsClass.ts, 63, 3)) ->c8 : Symbol(c8, Decl(commentsClass.ts, 48, 14)) +>i8_c : Symbol(i8_c, Decl(commentsClass.ts, 62, 3)) +>c8 : Symbol(c8, Decl(commentsClass.ts, 47, 14)) class c9 { ->c9 : Symbol(c9, Decl(commentsClass.ts, 63, 14)) +>c9 : Symbol(c9, Decl(commentsClass.ts, 62, 14)) constructor() { /// This is some detached comment diff --git a/tests/baselines/reference/commentsClass.types b/tests/baselines/reference/commentsClass.types index a4aca2ba15b6b..77ebc3a336a87 100644 --- a/tests/baselines/reference/commentsClass.types +++ b/tests/baselines/reference/commentsClass.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsClass.ts === - /** This is class c2 without constuctor*/ class c2 { >c2 : c2 diff --git a/tests/baselines/reference/commentsClassMembers.js b/tests/baselines/reference/commentsClassMembers.js index dacbde7a27698..9953e77ab7ec9 100644 --- a/tests/baselines/reference/commentsClassMembers.js +++ b/tests/baselines/reference/commentsClassMembers.js @@ -1,5 +1,4 @@ //// [commentsClassMembers.ts] - /** This is comment for c1*/ class c1 { /** p1 is property of c1*/ diff --git a/tests/baselines/reference/commentsClassMembers.symbols b/tests/baselines/reference/commentsClassMembers.symbols index 4cbf1292c10e6..f78523f638dce 100644 --- a/tests/baselines/reference/commentsClassMembers.symbols +++ b/tests/baselines/reference/commentsClassMembers.symbols @@ -1,706 +1,705 @@ === tests/cases/compiler/commentsClassMembers.ts === - /** This is comment for c1*/ class c1 { >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) /** p1 is property of c1*/ public p1: number; ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) /** sum with property*/ public p2(/** number to add*/b: number) { ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 6, 14)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 5, 14)) return this.p1 + b; ->this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 6, 14)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 5, 14)) } /* trailing comment of method*/ /** getter property*/ public get p3() { ->p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) +>p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) return this.p2(this.p1); ->this.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) +>this.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) }// trailing comment Getter /** setter property*/ public set p3(/** this is value*/value: number) { ->p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 14, 18)) +>p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 13, 18)) this.p1 = this.p2(value); ->this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) ->this.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) +>this.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 14, 18)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 13, 18)) }// trailing comment Setter /** pp1 is property of c1*/ private pp1: number; ->pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) +>pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) /** sum with property*/ private pp2(/** number to add*/b: number) { ->pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 20, 16)) +>pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 19, 16)) return this.p1 + b; ->this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>this.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 20, 16)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 19, 16)) } // trailing comment of method /** getter property*/ private get pp3() { ->pp3 : Symbol(c1.pp3, Decl(commentsClassMembers.ts, 22, 5), Decl(commentsClassMembers.ts, 26, 5)) +>pp3 : Symbol(c1.pp3, Decl(commentsClassMembers.ts, 21, 5), Decl(commentsClassMembers.ts, 25, 5)) return this.pp2(this.pp1); ->this.pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) +>this.pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) ->this.pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) +>pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) +>this.pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) +>pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) } /** setter property*/ private set pp3( /** this is value*/value: number) { ->pp3 : Symbol(c1.pp3, Decl(commentsClassMembers.ts, 22, 5), Decl(commentsClassMembers.ts, 26, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 28, 20)) +>pp3 : Symbol(c1.pp3, Decl(commentsClassMembers.ts, 21, 5), Decl(commentsClassMembers.ts, 25, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 27, 20)) this.pp1 = this.pp2(value); ->this.pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) +>this.pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 16, 5)) ->this.pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) +>pp1 : Symbol(c1.pp1, Decl(commentsClassMembers.ts, 15, 5)) +>this.pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 18, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 28, 20)) +>pp2 : Symbol(c1.pp2, Decl(commentsClassMembers.ts, 17, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 27, 20)) } /** Constructor method*/ constructor() { } /** s1 is static property of c1*/ static s1: number; ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) /** static sum with property*/ static s2(/** number to add*/b: number) { ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 37, 14)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 36, 14)) return c1.s1 + b; ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 37, 14)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 36, 14)) } /** static getter property*/ static get s3() { ->s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) +>s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) return c1.s2(c1.s1); ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) } /*trailing comment 1 getter*/ /** setter property*/ static set s3( /** this is value*/value: number) { ->s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 45, 18)) +>s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 44, 18)) c1.s1 = c1.s2(value); ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 45, 18)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 44, 18)) }/*trailing comment 2 */ /*setter*/ public nc_p1: number; ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) public nc_p2(b: number) { ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 49, 17)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 48, 17)) return this.nc_p1 + b; ->this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 49, 17)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 48, 17)) } public get nc_p3() { ->nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) +>nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) return this.nc_p2(this.nc_p1); ->this.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) +>this.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) } public set nc_p3(value: number) { ->nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 55, 21)) +>nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 54, 21)) this.nc_p1 = this.nc_p2(value); ->this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>this.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) ->this.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) +>this.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 55, 21)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 54, 21)) } private nc_pp1: number; ->nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) private nc_pp2(b: number) { ->nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 59, 19)) +>nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 58, 19)) return this.nc_pp1 + b; ->this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 59, 19)) +>nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 58, 19)) } private get nc_pp3() { ->nc_pp3 : Symbol(c1.nc_pp3, Decl(commentsClassMembers.ts, 61, 5), Decl(commentsClassMembers.ts, 64, 5)) +>nc_pp3 : Symbol(c1.nc_pp3, Decl(commentsClassMembers.ts, 60, 5), Decl(commentsClassMembers.ts, 63, 5)) return this.nc_pp2(this.nc_pp1); ->this.nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) +>this.nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) ->this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) +>this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) } private set nc_pp3(value: number) { ->nc_pp3 : Symbol(c1.nc_pp3, Decl(commentsClassMembers.ts, 61, 5), Decl(commentsClassMembers.ts, 64, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 65, 23)) +>nc_pp3 : Symbol(c1.nc_pp3, Decl(commentsClassMembers.ts, 60, 5), Decl(commentsClassMembers.ts, 63, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 64, 23)) this.nc_pp1 = this.nc_pp2(value); ->this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) +>this.nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 57, 5)) ->this.nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) +>nc_pp1 : Symbol(c1.nc_pp1, Decl(commentsClassMembers.ts, 56, 5)) +>this.nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 58, 27)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 65, 23)) +>nc_pp2 : Symbol(c1.nc_pp2, Decl(commentsClassMembers.ts, 57, 27)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 64, 23)) } static nc_s1: number; ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) static nc_s2(b: number) { ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 69, 17)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 68, 17)) return c1.nc_s1 + b; ->c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 69, 17)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 68, 17)) } static get nc_s3() { ->nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) +>nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) return c1.nc_s2(c1.nc_s1); ->c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) ->c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) +>c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) } static set nc_s3(value: number) { ->nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 75, 21)) +>nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 74, 21)) c1.nc_s1 = c1.nc_s2(value); ->c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) ->c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) +>c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 75, 21)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 74, 21)) } // p1 is property of c1 public a_p1: number; ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) // sum with property public a_p2(b: number) { ->a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 82, 16)) +>a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 81, 16)) return this.a_p1 + b; ->this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 82, 16)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 81, 16)) } // getter property public get a_p3() { ->a_p3 : Symbol(c1.a_p3, Decl(commentsClassMembers.ts, 84, 5), Decl(commentsClassMembers.ts, 88, 5)) +>a_p3 : Symbol(c1.a_p3, Decl(commentsClassMembers.ts, 83, 5), Decl(commentsClassMembers.ts, 87, 5)) return this.a_p2(this.a_p1); ->this.a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) +>this.a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) ->this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) +>this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) } // setter property public set a_p3(value: number) { ->a_p3 : Symbol(c1.a_p3, Decl(commentsClassMembers.ts, 84, 5), Decl(commentsClassMembers.ts, 88, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 90, 20)) +>a_p3 : Symbol(c1.a_p3, Decl(commentsClassMembers.ts, 83, 5), Decl(commentsClassMembers.ts, 87, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 89, 20)) this.a_p1 = this.a_p2(value); ->this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) ->this.a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) +>this.a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 80, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 90, 20)) +>a_p2 : Symbol(c1.a_p2, Decl(commentsClassMembers.ts, 79, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 89, 20)) } // pp1 is property of c1 private a_pp1: number; ->a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) +>a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) // sum with property private a_pp2(b: number) { ->a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 96, 18)) +>a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 95, 18)) return this.a_p1 + b; ->this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) +>this.a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 77, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 96, 18)) +>a_p1 : Symbol(c1.a_p1, Decl(commentsClassMembers.ts, 76, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 95, 18)) } // getter property private get a_pp3() { ->a_pp3 : Symbol(c1.a_pp3, Decl(commentsClassMembers.ts, 98, 5), Decl(commentsClassMembers.ts, 102, 5)) +>a_pp3 : Symbol(c1.a_pp3, Decl(commentsClassMembers.ts, 97, 5), Decl(commentsClassMembers.ts, 101, 5)) return this.a_pp2(this.a_pp1); ->this.a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) +>this.a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) ->this.a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) +>a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) +>this.a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) +>a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) } // setter property private set a_pp3(value: number) { ->a_pp3 : Symbol(c1.a_pp3, Decl(commentsClassMembers.ts, 98, 5), Decl(commentsClassMembers.ts, 102, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 104, 22)) +>a_pp3 : Symbol(c1.a_pp3, Decl(commentsClassMembers.ts, 97, 5), Decl(commentsClassMembers.ts, 101, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 103, 22)) this.a_pp1 = this.a_pp2(value); ->this.a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) +>this.a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 92, 5)) ->this.a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) +>a_pp1 : Symbol(c1.a_pp1, Decl(commentsClassMembers.ts, 91, 5)) +>this.a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 94, 26)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 104, 22)) +>a_pp2 : Symbol(c1.a_pp2, Decl(commentsClassMembers.ts, 93, 26)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 103, 22)) } // s1 is static property of c1 static a_s1: number; ->a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) +>a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) // static sum with property static a_s2(b: number) { ->a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 109, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 111, 16)) +>a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 108, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 110, 16)) return c1.a_s1 + b; ->c1.a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) +>c1.a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 111, 16)) +>a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 110, 16)) } // static getter property static get a_s3() { ->a_s3 : Symbol(c1.a_s3, Decl(commentsClassMembers.ts, 113, 5), Decl(commentsClassMembers.ts, 117, 5)) +>a_s3 : Symbol(c1.a_s3, Decl(commentsClassMembers.ts, 112, 5), Decl(commentsClassMembers.ts, 116, 5)) return c1.s2(c1.s1); ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) } // setter property static set a_s3(value: number) { ->a_s3 : Symbol(c1.a_s3, Decl(commentsClassMembers.ts, 113, 5), Decl(commentsClassMembers.ts, 117, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 120, 20)) +>a_s3 : Symbol(c1.a_s3, Decl(commentsClassMembers.ts, 112, 5), Decl(commentsClassMembers.ts, 116, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 119, 20)) c1.a_s1 = c1.a_s2(value); ->c1.a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) +>c1.a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 106, 5)) ->c1.a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 109, 24)) +>a_s1 : Symbol(c1.a_s1, Decl(commentsClassMembers.ts, 105, 5)) +>c1.a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 108, 24)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 109, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 120, 20)) +>a_s2 : Symbol(c1.a_s2, Decl(commentsClassMembers.ts, 108, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 119, 20)) } /** p1 is property of c1 */ public b_p1: number; ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) /** sum with property */ public b_p2(b: number) { ->b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 127, 16)) +>b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 126, 16)) return this.b_p1 + b; ->this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 127, 16)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 126, 16)) } /** getter property */ public get b_p3() { ->b_p3 : Symbol(c1.b_p3, Decl(commentsClassMembers.ts, 129, 5), Decl(commentsClassMembers.ts, 133, 5)) +>b_p3 : Symbol(c1.b_p3, Decl(commentsClassMembers.ts, 128, 5), Decl(commentsClassMembers.ts, 132, 5)) return this.b_p2(this.b_p1); ->this.b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) +>this.b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) ->this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) +>this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) } /** setter property */ public set b_p3(value: number) { ->b_p3 : Symbol(c1.b_p3, Decl(commentsClassMembers.ts, 129, 5), Decl(commentsClassMembers.ts, 133, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 135, 20)) +>b_p3 : Symbol(c1.b_p3, Decl(commentsClassMembers.ts, 128, 5), Decl(commentsClassMembers.ts, 132, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 134, 20)) this.b_p1 = this.b_p2(value); ->this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) ->this.b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) +>this.b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 125, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 135, 20)) +>b_p2 : Symbol(c1.b_p2, Decl(commentsClassMembers.ts, 124, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 134, 20)) } /** pp1 is property of c1 */ private b_pp1: number; ->b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) +>b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) /** sum with property */ private b_pp2(b: number) { ->b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 141, 18)) +>b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 140, 18)) return this.b_p1 + b; ->this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) +>this.b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 122, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 141, 18)) +>b_p1 : Symbol(c1.b_p1, Decl(commentsClassMembers.ts, 121, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 140, 18)) } /** getter property */ private get b_pp3() { ->b_pp3 : Symbol(c1.b_pp3, Decl(commentsClassMembers.ts, 143, 5), Decl(commentsClassMembers.ts, 147, 5)) +>b_pp3 : Symbol(c1.b_pp3, Decl(commentsClassMembers.ts, 142, 5), Decl(commentsClassMembers.ts, 146, 5)) return this.b_pp2(this.b_pp1); ->this.b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) +>this.b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) ->this.b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) +>b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) +>this.b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) +>b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) } /** setter property */ private set b_pp3(value: number) { ->b_pp3 : Symbol(c1.b_pp3, Decl(commentsClassMembers.ts, 143, 5), Decl(commentsClassMembers.ts, 147, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 149, 22)) +>b_pp3 : Symbol(c1.b_pp3, Decl(commentsClassMembers.ts, 142, 5), Decl(commentsClassMembers.ts, 146, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 148, 22)) this.b_pp1 = this.b_pp2(value); ->this.b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) +>this.b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 137, 5)) ->this.b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) +>b_pp1 : Symbol(c1.b_pp1, Decl(commentsClassMembers.ts, 136, 5)) +>this.b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) >this : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 139, 26)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 149, 22)) +>b_pp2 : Symbol(c1.b_pp2, Decl(commentsClassMembers.ts, 138, 26)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 148, 22)) } /** s1 is static property of c1 */ static b_s1: number; ->b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) +>b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) /** static sum with property */ static b_s2(b: number) { ->b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 154, 24)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 156, 16)) +>b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 153, 24)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 155, 16)) return c1.b_s1 + b; ->c1.b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) +>c1.b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) ->b : Symbol(b, Decl(commentsClassMembers.ts, 156, 16)) +>b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) +>b : Symbol(b, Decl(commentsClassMembers.ts, 155, 16)) } /** static getter property */ static get b_s3() { ->b_s3 : Symbol(c1.b_s3, Decl(commentsClassMembers.ts, 158, 5), Decl(commentsClassMembers.ts, 163, 5)) +>b_s3 : Symbol(c1.b_s3, Decl(commentsClassMembers.ts, 157, 5), Decl(commentsClassMembers.ts, 162, 5)) return c1.s2(c1.s1); ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) } /** setter property */ static set b_s3(value: number) { ->b_s3 : Symbol(c1.b_s3, Decl(commentsClassMembers.ts, 158, 5), Decl(commentsClassMembers.ts, 163, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 167, 20)) +>b_s3 : Symbol(c1.b_s3, Decl(commentsClassMembers.ts, 157, 5), Decl(commentsClassMembers.ts, 162, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 166, 20)) /** setter */ c1.b_s1 = c1.b_s2(value); ->c1.b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) +>c1.b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 151, 5)) ->c1.b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 154, 24)) +>b_s1 : Symbol(c1.b_s1, Decl(commentsClassMembers.ts, 150, 5)) +>c1.b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 153, 24)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 154, 24)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 167, 20)) +>b_s2 : Symbol(c1.b_s2, Decl(commentsClassMembers.ts, 153, 24)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 166, 20)) } } var i1 = new c1(); ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) var i1_p = i1.p1; ->i1_p : Symbol(i1_p, Decl(commentsClassMembers.ts, 173, 3)) ->i1.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 2, 10)) +>i1_p : Symbol(i1_p, Decl(commentsClassMembers.ts, 172, 3)) +>i1.p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p1 : Symbol(c1.p1, Decl(commentsClassMembers.ts, 1, 10)) var i1_f = i1.p2; ->i1_f : Symbol(i1_f, Decl(commentsClassMembers.ts, 174, 3)) ->i1.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) +>i1_f : Symbol(i1_f, Decl(commentsClassMembers.ts, 173, 3)) +>i1.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) var i1_r = i1.p2(20); ->i1_r : Symbol(i1_r, Decl(commentsClassMembers.ts, 175, 3)) ->i1.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 4, 22)) +>i1_r : Symbol(i1_r, Decl(commentsClassMembers.ts, 174, 3)) +>i1.p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p2 : Symbol(c1.p2, Decl(commentsClassMembers.ts, 3, 22)) var i1_prop = i1.p3; ->i1_prop : Symbol(i1_prop, Decl(commentsClassMembers.ts, 176, 3)) ->i1.p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) +>i1_prop : Symbol(i1_prop, Decl(commentsClassMembers.ts, 175, 3)) +>i1.p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) i1.p3 = i1_prop; ->i1.p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 8, 5), Decl(commentsClassMembers.ts, 12, 5)) ->i1_prop : Symbol(i1_prop, Decl(commentsClassMembers.ts, 176, 3)) +>i1.p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>p3 : Symbol(c1.p3, Decl(commentsClassMembers.ts, 7, 5), Decl(commentsClassMembers.ts, 11, 5)) +>i1_prop : Symbol(i1_prop, Decl(commentsClassMembers.ts, 175, 3)) var i1_nc_p = i1.nc_p1; ->i1_nc_p : Symbol(i1_nc_p, Decl(commentsClassMembers.ts, 178, 3)) ->i1.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 47, 5)) +>i1_nc_p : Symbol(i1_nc_p, Decl(commentsClassMembers.ts, 177, 3)) +>i1.nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsClassMembers.ts, 46, 5)) var i1_ncf = i1.nc_p2; ->i1_ncf : Symbol(i1_ncf, Decl(commentsClassMembers.ts, 179, 3)) ->i1.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) +>i1_ncf : Symbol(i1_ncf, Decl(commentsClassMembers.ts, 178, 3)) +>i1.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) var i1_ncr = i1.nc_p2(20); ->i1_ncr : Symbol(i1_ncr, Decl(commentsClassMembers.ts, 180, 3)) ->i1.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 48, 25)) +>i1_ncr : Symbol(i1_ncr, Decl(commentsClassMembers.ts, 179, 3)) +>i1.nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p2 : Symbol(c1.nc_p2, Decl(commentsClassMembers.ts, 47, 25)) var i1_ncprop = i1.nc_p3; ->i1_ncprop : Symbol(i1_ncprop, Decl(commentsClassMembers.ts, 181, 3)) ->i1.nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) +>i1_ncprop : Symbol(i1_ncprop, Decl(commentsClassMembers.ts, 180, 3)) +>i1.nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) i1.nc_p3 = i1_ncprop; ->i1.nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) ->i1 : Symbol(i1, Decl(commentsClassMembers.ts, 172, 3)) ->nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 51, 5), Decl(commentsClassMembers.ts, 54, 5)) ->i1_ncprop : Symbol(i1_ncprop, Decl(commentsClassMembers.ts, 181, 3)) +>i1.nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) +>i1 : Symbol(i1, Decl(commentsClassMembers.ts, 171, 3)) +>nc_p3 : Symbol(c1.nc_p3, Decl(commentsClassMembers.ts, 50, 5), Decl(commentsClassMembers.ts, 53, 5)) +>i1_ncprop : Symbol(i1_ncprop, Decl(commentsClassMembers.ts, 180, 3)) var i1_s_p = c1.s1; ->i1_s_p : Symbol(i1_s_p, Decl(commentsClassMembers.ts, 183, 3)) ->c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>i1_s_p : Symbol(i1_s_p, Decl(commentsClassMembers.ts, 182, 3)) +>c1.s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 33, 5)) +>s1 : Symbol(c1.s1, Decl(commentsClassMembers.ts, 32, 5)) var i1_s_f = c1.s2; ->i1_s_f : Symbol(i1_s_f, Decl(commentsClassMembers.ts, 184, 3)) ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>i1_s_f : Symbol(i1_s_f, Decl(commentsClassMembers.ts, 183, 3)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) var i1_s_r = c1.s2(20); ->i1_s_r : Symbol(i1_s_r, Decl(commentsClassMembers.ts, 185, 3)) ->c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>i1_s_r : Symbol(i1_s_r, Decl(commentsClassMembers.ts, 184, 3)) +>c1.s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 35, 22)) +>s2 : Symbol(c1.s2, Decl(commentsClassMembers.ts, 34, 22)) var i1_s_prop = c1.s3; ->i1_s_prop : Symbol(i1_s_prop, Decl(commentsClassMembers.ts, 186, 3)) ->c1.s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) +>i1_s_prop : Symbol(i1_s_prop, Decl(commentsClassMembers.ts, 185, 3)) +>c1.s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) +>s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) c1.s3 = i1_s_prop; ->c1.s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) +>c1.s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 39, 5), Decl(commentsClassMembers.ts, 43, 5)) ->i1_s_prop : Symbol(i1_s_prop, Decl(commentsClassMembers.ts, 186, 3)) +>s3 : Symbol(c1.s3, Decl(commentsClassMembers.ts, 38, 5), Decl(commentsClassMembers.ts, 42, 5)) +>i1_s_prop : Symbol(i1_s_prop, Decl(commentsClassMembers.ts, 185, 3)) var i1_s_nc_p = c1.nc_s1; ->i1_s_nc_p : Symbol(i1_s_nc_p, Decl(commentsClassMembers.ts, 188, 3)) ->c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>i1_s_nc_p : Symbol(i1_s_nc_p, Decl(commentsClassMembers.ts, 187, 3)) +>c1.nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 67, 5)) +>nc_s1 : Symbol(c1.nc_s1, Decl(commentsClassMembers.ts, 66, 5)) var i1_s_ncf = c1.nc_s2; ->i1_s_ncf : Symbol(i1_s_ncf, Decl(commentsClassMembers.ts, 189, 3)) ->c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>i1_s_ncf : Symbol(i1_s_ncf, Decl(commentsClassMembers.ts, 188, 3)) +>c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) var i1_s_ncr = c1.nc_s2(20); ->i1_s_ncr : Symbol(i1_s_ncr, Decl(commentsClassMembers.ts, 190, 3)) ->c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>i1_s_ncr : Symbol(i1_s_ncr, Decl(commentsClassMembers.ts, 189, 3)) +>c1.nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 68, 25)) +>nc_s2 : Symbol(c1.nc_s2, Decl(commentsClassMembers.ts, 67, 25)) var i1_s_ncprop = c1.nc_s3; ->i1_s_ncprop : Symbol(i1_s_ncprop, Decl(commentsClassMembers.ts, 191, 3)) ->c1.nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) +>i1_s_ncprop : Symbol(i1_s_ncprop, Decl(commentsClassMembers.ts, 190, 3)) +>c1.nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) +>nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) c1.nc_s3 = i1_s_ncprop; ->c1.nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) +>c1.nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) ->nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 71, 5), Decl(commentsClassMembers.ts, 74, 5)) ->i1_s_ncprop : Symbol(i1_s_ncprop, Decl(commentsClassMembers.ts, 191, 3)) +>nc_s3 : Symbol(c1.nc_s3, Decl(commentsClassMembers.ts, 70, 5), Decl(commentsClassMembers.ts, 73, 5)) +>i1_s_ncprop : Symbol(i1_s_ncprop, Decl(commentsClassMembers.ts, 190, 3)) var i1_c = c1; ->i1_c : Symbol(i1_c, Decl(commentsClassMembers.ts, 193, 3)) +>i1_c : Symbol(i1_c, Decl(commentsClassMembers.ts, 192, 3)) >c1 : Symbol(c1, Decl(commentsClassMembers.ts, 0, 0)) class cProperties { ->cProperties : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) +>cProperties : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) private val: number; ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) /** getter only property*/ public get p1() { ->p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 195, 24)) +>p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 194, 24)) return this.val; ->this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->this : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) +>this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>this : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) } // trailing comment of only getter public get nc_p1() { ->nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 199, 5)) +>nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 198, 5)) return this.val; ->this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->this : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) +>this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>this : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) } /**setter only property*/ public set p2(value: number) { ->p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 202, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 204, 18)) +>p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 201, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 203, 18)) this.val = value; ->this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->this : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 204, 18)) +>this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>this : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 203, 18)) } public set nc_p2(value: number) { ->nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 206, 5)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 207, 21)) +>nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 205, 5)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 206, 21)) this.val = value; ->this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->this : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) ->val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 194, 19)) ->value : Symbol(value, Decl(commentsClassMembers.ts, 207, 21)) +>this.val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>this : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) +>val : Symbol(cProperties.val, Decl(commentsClassMembers.ts, 193, 19)) +>value : Symbol(value, Decl(commentsClassMembers.ts, 206, 21)) } /* trailing comment of setter only*/ public x = 10; /*trailing comment for property*/ ->x : Symbol(cProperties.x, Decl(commentsClassMembers.ts, 209, 5)) +>x : Symbol(cProperties.x, Decl(commentsClassMembers.ts, 208, 5)) private y = 10; // trailing comment of // style ->y : Symbol(cProperties.y, Decl(commentsClassMembers.ts, 211, 18)) +>y : Symbol(cProperties.y, Decl(commentsClassMembers.ts, 210, 18)) } var cProperties_i = new cProperties(); ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->cProperties : Symbol(cProperties, Decl(commentsClassMembers.ts, 193, 14)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>cProperties : Symbol(cProperties, Decl(commentsClassMembers.ts, 192, 14)) cProperties_i.p2 = cProperties_i.p1; ->cProperties_i.p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 202, 5)) ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 202, 5)) ->cProperties_i.p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 195, 24)) ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 195, 24)) +>cProperties_i.p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 201, 5)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>p2 : Symbol(cProperties.p2, Decl(commentsClassMembers.ts, 201, 5)) +>cProperties_i.p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 194, 24)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>p1 : Symbol(cProperties.p1, Decl(commentsClassMembers.ts, 194, 24)) cProperties_i.nc_p2 = cProperties_i.nc_p1; ->cProperties_i.nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 206, 5)) ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 206, 5)) ->cProperties_i.nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 199, 5)) ->cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 214, 3)) ->nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 199, 5)) +>cProperties_i.nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 205, 5)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>nc_p2 : Symbol(cProperties.nc_p2, Decl(commentsClassMembers.ts, 205, 5)) +>cProperties_i.nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 198, 5)) +>cProperties_i : Symbol(cProperties_i, Decl(commentsClassMembers.ts, 213, 3)) +>nc_p1 : Symbol(cProperties.nc_p1, Decl(commentsClassMembers.ts, 198, 5)) diff --git a/tests/baselines/reference/commentsClassMembers.types b/tests/baselines/reference/commentsClassMembers.types index 3824b8acac016..cd1bfbdd6f0cc 100644 --- a/tests/baselines/reference/commentsClassMembers.types +++ b/tests/baselines/reference/commentsClassMembers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsClassMembers.ts === - /** This is comment for c1*/ class c1 { >c1 : c1 diff --git a/tests/baselines/reference/commentsCommentParsing.js b/tests/baselines/reference/commentsCommentParsing.js index 24b2a459bf72d..db9b5b6632acc 100644 --- a/tests/baselines/reference/commentsCommentParsing.js +++ b/tests/baselines/reference/commentsCommentParsing.js @@ -1,5 +1,4 @@ //// [commentsCommentParsing.ts] - /// This is simple /// comments function simple() { } diff --git a/tests/baselines/reference/commentsCommentParsing.symbols b/tests/baselines/reference/commentsCommentParsing.symbols index abd98074b526b..58dac01ae4e13 100644 --- a/tests/baselines/reference/commentsCommentParsing.symbols +++ b/tests/baselines/reference/commentsCommentParsing.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsCommentParsing.ts === - /// This is simple /// comments function simple() { >simple : Symbol(simple, Decl(commentsCommentParsing.ts, 0, 0)) @@ -12,27 +11,27 @@ simple(); /// This is example of multiline /// comments /// Another multiLine function multiLine() { ->multiLine : Symbol(multiLine, Decl(commentsCommentParsing.ts, 5, 9)) +>multiLine : Symbol(multiLine, Decl(commentsCommentParsing.ts, 4, 9)) } multiLine(); ->multiLine : Symbol(multiLine, Decl(commentsCommentParsing.ts, 5, 9)) +>multiLine : Symbol(multiLine, Decl(commentsCommentParsing.ts, 4, 9)) /** this is eg of single line jsdoc style comment */ function jsDocSingleLine() { ->jsDocSingleLine : Symbol(jsDocSingleLine, Decl(commentsCommentParsing.ts, 12, 12)) +>jsDocSingleLine : Symbol(jsDocSingleLine, Decl(commentsCommentParsing.ts, 11, 12)) } jsDocSingleLine(); ->jsDocSingleLine : Symbol(jsDocSingleLine, Decl(commentsCommentParsing.ts, 12, 12)) +>jsDocSingleLine : Symbol(jsDocSingleLine, Decl(commentsCommentParsing.ts, 11, 12)) /** this is multiple line jsdoc stule comment *New line1 *New Line2*/ function jsDocMultiLine() { ->jsDocMultiLine : Symbol(jsDocMultiLine, Decl(commentsCommentParsing.ts, 17, 18)) +>jsDocMultiLine : Symbol(jsDocMultiLine, Decl(commentsCommentParsing.ts, 16, 18)) } jsDocMultiLine(); ->jsDocMultiLine : Symbol(jsDocMultiLine, Decl(commentsCommentParsing.ts, 17, 18)) +>jsDocMultiLine : Symbol(jsDocMultiLine, Decl(commentsCommentParsing.ts, 16, 18)) /** this is multiple line jsdoc stule comment *New line1 @@ -40,54 +39,54 @@ jsDocMultiLine(); /** Shoul mege this line as well * and this too*/ /** Another this one too*/ function jsDocMultiLineMerge() { ->jsDocMultiLineMerge : Symbol(jsDocMultiLineMerge, Decl(commentsCommentParsing.ts, 25, 17)) +>jsDocMultiLineMerge : Symbol(jsDocMultiLineMerge, Decl(commentsCommentParsing.ts, 24, 17)) } jsDocMultiLineMerge(); ->jsDocMultiLineMerge : Symbol(jsDocMultiLineMerge, Decl(commentsCommentParsing.ts, 25, 17)) +>jsDocMultiLineMerge : Symbol(jsDocMultiLineMerge, Decl(commentsCommentParsing.ts, 24, 17)) /// Triple slash comment /** jsdoc comment */ function jsDocMixedComments1() { ->jsDocMixedComments1 : Symbol(jsDocMixedComments1, Decl(commentsCommentParsing.ts, 34, 22)) +>jsDocMixedComments1 : Symbol(jsDocMixedComments1, Decl(commentsCommentParsing.ts, 33, 22)) } jsDocMixedComments1(); ->jsDocMixedComments1 : Symbol(jsDocMixedComments1, Decl(commentsCommentParsing.ts, 34, 22)) +>jsDocMixedComments1 : Symbol(jsDocMixedComments1, Decl(commentsCommentParsing.ts, 33, 22)) /// Triple slash comment /** jsdoc comment */ /*** another jsDocComment*/ function jsDocMixedComments2() { ->jsDocMixedComments2 : Symbol(jsDocMixedComments2, Decl(commentsCommentParsing.ts, 41, 22)) +>jsDocMixedComments2 : Symbol(jsDocMixedComments2, Decl(commentsCommentParsing.ts, 40, 22)) } jsDocMixedComments2(); ->jsDocMixedComments2 : Symbol(jsDocMixedComments2, Decl(commentsCommentParsing.ts, 41, 22)) +>jsDocMixedComments2 : Symbol(jsDocMixedComments2, Decl(commentsCommentParsing.ts, 40, 22)) /** jsdoc comment */ /*** another jsDocComment*/ /// Triple slash comment function jsDocMixedComments3() { ->jsDocMixedComments3 : Symbol(jsDocMixedComments3, Decl(commentsCommentParsing.ts, 47, 22)) +>jsDocMixedComments3 : Symbol(jsDocMixedComments3, Decl(commentsCommentParsing.ts, 46, 22)) } jsDocMixedComments3(); ->jsDocMixedComments3 : Symbol(jsDocMixedComments3, Decl(commentsCommentParsing.ts, 47, 22)) +>jsDocMixedComments3 : Symbol(jsDocMixedComments3, Decl(commentsCommentParsing.ts, 46, 22)) /** jsdoc comment */ /*** another jsDocComment*/ /// Triple slash comment /// Triple slash comment 2 function jsDocMixedComments4() { ->jsDocMixedComments4 : Symbol(jsDocMixedComments4, Decl(commentsCommentParsing.ts, 53, 22)) +>jsDocMixedComments4 : Symbol(jsDocMixedComments4, Decl(commentsCommentParsing.ts, 52, 22)) } jsDocMixedComments4(); ->jsDocMixedComments4 : Symbol(jsDocMixedComments4, Decl(commentsCommentParsing.ts, 53, 22)) +>jsDocMixedComments4 : Symbol(jsDocMixedComments4, Decl(commentsCommentParsing.ts, 52, 22)) /// Triple slash comment 1 /** jsdoc comment */ /*** another jsDocComment*/ /// Triple slash comment /// Triple slash comment 2 function jsDocMixedComments5() { ->jsDocMixedComments5 : Symbol(jsDocMixedComments5, Decl(commentsCommentParsing.ts, 60, 22)) +>jsDocMixedComments5 : Symbol(jsDocMixedComments5, Decl(commentsCommentParsing.ts, 59, 22)) } jsDocMixedComments5(); ->jsDocMixedComments5 : Symbol(jsDocMixedComments5, Decl(commentsCommentParsing.ts, 60, 22)) +>jsDocMixedComments5 : Symbol(jsDocMixedComments5, Decl(commentsCommentParsing.ts, 59, 22)) /*** another jsDocComment*/ /// Triple slash comment 1 @@ -95,46 +94,46 @@ jsDocMixedComments5(); /// Triple slash comment 2 /** jsdoc comment */ function jsDocMixedComments6() { ->jsDocMixedComments6 : Symbol(jsDocMixedComments6, Decl(commentsCommentParsing.ts, 68, 22)) +>jsDocMixedComments6 : Symbol(jsDocMixedComments6, Decl(commentsCommentParsing.ts, 67, 22)) } jsDocMixedComments6(); ->jsDocMixedComments6 : Symbol(jsDocMixedComments6, Decl(commentsCommentParsing.ts, 68, 22)) +>jsDocMixedComments6 : Symbol(jsDocMixedComments6, Decl(commentsCommentParsing.ts, 67, 22)) // This shoulnot be help comment function noHelpComment1() { ->noHelpComment1 : Symbol(noHelpComment1, Decl(commentsCommentParsing.ts, 77, 22)) +>noHelpComment1 : Symbol(noHelpComment1, Decl(commentsCommentParsing.ts, 76, 22)) } noHelpComment1(); ->noHelpComment1 : Symbol(noHelpComment1, Decl(commentsCommentParsing.ts, 77, 22)) +>noHelpComment1 : Symbol(noHelpComment1, Decl(commentsCommentParsing.ts, 76, 22)) /* This shoulnot be help comment */ function noHelpComment2() { ->noHelpComment2 : Symbol(noHelpComment2, Decl(commentsCommentParsing.ts, 82, 17)) +>noHelpComment2 : Symbol(noHelpComment2, Decl(commentsCommentParsing.ts, 81, 17)) } noHelpComment2(); ->noHelpComment2 : Symbol(noHelpComment2, Decl(commentsCommentParsing.ts, 82, 17)) +>noHelpComment2 : Symbol(noHelpComment2, Decl(commentsCommentParsing.ts, 81, 17)) function noHelpComment3() { ->noHelpComment3 : Symbol(noHelpComment3, Decl(commentsCommentParsing.ts, 87, 17)) +>noHelpComment3 : Symbol(noHelpComment3, Decl(commentsCommentParsing.ts, 86, 17)) } noHelpComment3(); ->noHelpComment3 : Symbol(noHelpComment3, Decl(commentsCommentParsing.ts, 87, 17)) +>noHelpComment3 : Symbol(noHelpComment3, Decl(commentsCommentParsing.ts, 86, 17)) /** Adds two integers and returns the result * @param {number} a first number * @param b second number */ function sum(a: number, b: number) { ->sum : Symbol(sum, Decl(commentsCommentParsing.ts, 91, 17)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 96, 13)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 96, 23)) +>sum : Symbol(sum, Decl(commentsCommentParsing.ts, 90, 17)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 95, 13)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 95, 23)) return a + b; ->a : Symbol(a, Decl(commentsCommentParsing.ts, 96, 13)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 96, 23)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 95, 13)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 95, 23)) } sum(10, 20); ->sum : Symbol(sum, Decl(commentsCommentParsing.ts, 91, 17)) +>sum : Symbol(sum, Decl(commentsCommentParsing.ts, 90, 17)) /** This is multiplication function*/ /** @param */ @@ -144,32 +143,32 @@ sum(10, 20); @param d @anotherTag*/ /** @param e LastParam @anotherTag*/ function multiply(a: number, b: number, c?: number, d?, e?) { ->multiply : Symbol(multiply, Decl(commentsCommentParsing.ts, 99, 12)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 107, 18)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 107, 28)) ->c : Symbol(c, Decl(commentsCommentParsing.ts, 107, 39)) ->d : Symbol(d, Decl(commentsCommentParsing.ts, 107, 51)) ->e : Symbol(e, Decl(commentsCommentParsing.ts, 107, 55)) +>multiply : Symbol(multiply, Decl(commentsCommentParsing.ts, 98, 12)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 106, 18)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 106, 28)) +>c : Symbol(c, Decl(commentsCommentParsing.ts, 106, 39)) +>d : Symbol(d, Decl(commentsCommentParsing.ts, 106, 51)) +>e : Symbol(e, Decl(commentsCommentParsing.ts, 106, 55)) } /** fn f1 with number * @param { string} b about b */ function f1(a: number); ->f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 108, 1), Decl(commentsCommentParsing.ts, 112, 23), Decl(commentsCommentParsing.ts, 113, 23)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 112, 12)) +>f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 107, 1), Decl(commentsCommentParsing.ts, 111, 23), Decl(commentsCommentParsing.ts, 112, 23)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 111, 12)) function f1(b: string); ->f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 108, 1), Decl(commentsCommentParsing.ts, 112, 23), Decl(commentsCommentParsing.ts, 113, 23)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 113, 12)) +>f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 107, 1), Decl(commentsCommentParsing.ts, 111, 23), Decl(commentsCommentParsing.ts, 112, 23)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 112, 12)) /**@param opt optional parameter*/ function f1(aOrb, opt?) { ->f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 108, 1), Decl(commentsCommentParsing.ts, 112, 23), Decl(commentsCommentParsing.ts, 113, 23)) ->aOrb : Symbol(aOrb, Decl(commentsCommentParsing.ts, 115, 12)) ->opt : Symbol(opt, Decl(commentsCommentParsing.ts, 115, 17)) +>f1 : Symbol(f1, Decl(commentsCommentParsing.ts, 107, 1), Decl(commentsCommentParsing.ts, 111, 23), Decl(commentsCommentParsing.ts, 112, 23)) +>aOrb : Symbol(aOrb, Decl(commentsCommentParsing.ts, 114, 12)) +>opt : Symbol(opt, Decl(commentsCommentParsing.ts, 114, 17)) return aOrb; ->aOrb : Symbol(aOrb, Decl(commentsCommentParsing.ts, 115, 12)) +>aOrb : Symbol(aOrb, Decl(commentsCommentParsing.ts, 114, 12)) } /** This is subtract function @param { a @@ -180,13 +179,13 @@ function f1(aOrb, opt?) { @param { { { () => string; } } f this is optional param f */ function subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string) { ->subtract : Symbol(subtract, Decl(commentsCommentParsing.ts, 117, 1)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 126, 18)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 126, 28)) ->c : Symbol(c, Decl(commentsCommentParsing.ts, 126, 39)) ->d : Symbol(d, Decl(commentsCommentParsing.ts, 126, 57)) ->e : Symbol(e, Decl(commentsCommentParsing.ts, 126, 75)) ->f : Symbol(f, Decl(commentsCommentParsing.ts, 126, 93)) +>subtract : Symbol(subtract, Decl(commentsCommentParsing.ts, 116, 1)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 125, 18)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 125, 28)) +>c : Symbol(c, Decl(commentsCommentParsing.ts, 125, 39)) +>d : Symbol(d, Decl(commentsCommentParsing.ts, 125, 57)) +>e : Symbol(e, Decl(commentsCommentParsing.ts, 125, 75)) +>f : Symbol(f, Decl(commentsCommentParsing.ts, 125, 93)) } /** this is square function @paramTag { number } a this is input number of paramTag @@ -194,12 +193,12 @@ function subtract(a: number, b: number, c?: () => string, d?: () => string, e?: @returnType { number } it is return type */ function square(a: number) { ->square : Symbol(square, Decl(commentsCommentParsing.ts, 127, 1)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 133, 16)) +>square : Symbol(square, Decl(commentsCommentParsing.ts, 126, 1)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 132, 16)) return a * a; ->a : Symbol(a, Decl(commentsCommentParsing.ts, 133, 16)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 133, 16)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 132, 16)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 132, 16)) } /** this is divide function @param { number} a this is a @@ -207,29 +206,29 @@ function square(a: number) { @param { number} b this is b */ function divide(a: number, b: number) { ->divide : Symbol(divide, Decl(commentsCommentParsing.ts, 135, 1)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 141, 16)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 141, 26)) +>divide : Symbol(divide, Decl(commentsCommentParsing.ts, 134, 1)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 140, 16)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 140, 26)) } /** this is jsdoc style function with param tag as well as inline parameter help *@param a it is first parameter *@param c it is third parameter */ function jsDocParamTest(/** this is inline comment for a */a: number, /** this is inline comment for b*/ b: number, c: number, d: number) { ->jsDocParamTest : Symbol(jsDocParamTest, Decl(commentsCommentParsing.ts, 142, 1)) ->a : Symbol(a, Decl(commentsCommentParsing.ts, 147, 24)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 147, 69)) ->c : Symbol(c, Decl(commentsCommentParsing.ts, 147, 115)) ->d : Symbol(d, Decl(commentsCommentParsing.ts, 147, 126)) +>jsDocParamTest : Symbol(jsDocParamTest, Decl(commentsCommentParsing.ts, 141, 1)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 146, 24)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 146, 69)) +>c : Symbol(c, Decl(commentsCommentParsing.ts, 146, 115)) +>d : Symbol(d, Decl(commentsCommentParsing.ts, 146, 126)) return a + b + c + d; ->a : Symbol(a, Decl(commentsCommentParsing.ts, 147, 24)) ->b : Symbol(b, Decl(commentsCommentParsing.ts, 147, 69)) ->c : Symbol(c, Decl(commentsCommentParsing.ts, 147, 115)) ->d : Symbol(d, Decl(commentsCommentParsing.ts, 147, 126)) +>a : Symbol(a, Decl(commentsCommentParsing.ts, 146, 24)) +>b : Symbol(b, Decl(commentsCommentParsing.ts, 146, 69)) +>c : Symbol(c, Decl(commentsCommentParsing.ts, 146, 115)) +>d : Symbol(d, Decl(commentsCommentParsing.ts, 146, 126)) } /**/ class NoQuickInfoClass { ->NoQuickInfoClass : Symbol(NoQuickInfoClass, Decl(commentsCommentParsing.ts, 149, 1)) +>NoQuickInfoClass : Symbol(NoQuickInfoClass, Decl(commentsCommentParsing.ts, 148, 1)) } diff --git a/tests/baselines/reference/commentsCommentParsing.types b/tests/baselines/reference/commentsCommentParsing.types index b41822679d864..2d8e9c8658ed2 100644 --- a/tests/baselines/reference/commentsCommentParsing.types +++ b/tests/baselines/reference/commentsCommentParsing.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsCommentParsing.ts === - /// This is simple /// comments function simple() { >simple : () => void diff --git a/tests/baselines/reference/commentsDottedModuleName.js b/tests/baselines/reference/commentsDottedModuleName.js index 1c1df10403940..89c959ccdab83 100644 --- a/tests/baselines/reference/commentsDottedModuleName.js +++ b/tests/baselines/reference/commentsDottedModuleName.js @@ -1,5 +1,4 @@ //// [commentsDottedModuleName.ts] - /** this is multi declare module*/ export module outerModule.InnerModule { /// class b comment diff --git a/tests/baselines/reference/commentsDottedModuleName.symbols b/tests/baselines/reference/commentsDottedModuleName.symbols index 99083b11e3c2a..b26300edd621f 100644 --- a/tests/baselines/reference/commentsDottedModuleName.symbols +++ b/tests/baselines/reference/commentsDottedModuleName.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/commentsDottedModuleName.ts === - /** this is multi declare module*/ export module outerModule.InnerModule { >outerModule : Symbol(outerModule, Decl(commentsDottedModuleName.ts, 0, 0)) ->InnerModule : Symbol(InnerModule, Decl(commentsDottedModuleName.ts, 2, 26)) +>InnerModule : Symbol(InnerModule, Decl(commentsDottedModuleName.ts, 1, 26)) /// class b comment export class b { ->b : Symbol(b, Decl(commentsDottedModuleName.ts, 2, 39)) +>b : Symbol(b, Decl(commentsDottedModuleName.ts, 1, 39)) } } diff --git a/tests/baselines/reference/commentsDottedModuleName.types b/tests/baselines/reference/commentsDottedModuleName.types index 53195bfccfa4c..377ee40b473b2 100644 --- a/tests/baselines/reference/commentsDottedModuleName.types +++ b/tests/baselines/reference/commentsDottedModuleName.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsDottedModuleName.ts === - /** this is multi declare module*/ export module outerModule.InnerModule { >outerModule : typeof outerModule diff --git a/tests/baselines/reference/commentsEnums.js b/tests/baselines/reference/commentsEnums.js index 7be17f085b0ac..c8cd4e3820614 100644 --- a/tests/baselines/reference/commentsEnums.js +++ b/tests/baselines/reference/commentsEnums.js @@ -1,5 +1,4 @@ //// [commentsEnums.ts] - /** Enum of colors*/ enum Colors { /** Fancy name for 'blue'*/ diff --git a/tests/baselines/reference/commentsEnums.symbols b/tests/baselines/reference/commentsEnums.symbols index 0f5910f4ee799..912d5a61fc4d4 100644 --- a/tests/baselines/reference/commentsEnums.symbols +++ b/tests/baselines/reference/commentsEnums.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/commentsEnums.ts === - /** Enum of colors*/ enum Colors { >Colors : Symbol(Colors, Decl(commentsEnums.ts, 0, 0)) /** Fancy name for 'blue'*/ Cornflower /* blue */, ->Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 2, 13)) +>Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 1, 13)) /** Fancy name for 'pink'*/ FancyPink ->FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 4, 26)) +>FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 3, 26)) } // trailing comment var x = Colors.Cornflower; ->x : Symbol(x, Decl(commentsEnums.ts, 8, 3)) ->Colors.Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 2, 13)) +>x : Symbol(x, Decl(commentsEnums.ts, 7, 3)) +>Colors.Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 1, 13)) >Colors : Symbol(Colors, Decl(commentsEnums.ts, 0, 0)) ->Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 2, 13)) +>Cornflower : Symbol(Colors.Cornflower, Decl(commentsEnums.ts, 1, 13)) x = Colors.FancyPink; ->x : Symbol(x, Decl(commentsEnums.ts, 8, 3)) ->Colors.FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 4, 26)) +>x : Symbol(x, Decl(commentsEnums.ts, 7, 3)) +>Colors.FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 3, 26)) >Colors : Symbol(Colors, Decl(commentsEnums.ts, 0, 0)) ->FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 4, 26)) +>FancyPink : Symbol(Colors.FancyPink, Decl(commentsEnums.ts, 3, 26)) diff --git a/tests/baselines/reference/commentsEnums.types b/tests/baselines/reference/commentsEnums.types index 71d062f790aca..747f917944047 100644 --- a/tests/baselines/reference/commentsEnums.types +++ b/tests/baselines/reference/commentsEnums.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsEnums.ts === - /** Enum of colors*/ enum Colors { >Colors : Colors diff --git a/tests/baselines/reference/commentsExternalModules.js b/tests/baselines/reference/commentsExternalModules.js index 39002f90d9105..7556e8855fbc6 100644 --- a/tests/baselines/reference/commentsExternalModules.js +++ b/tests/baselines/reference/commentsExternalModules.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsExternalModules.ts] //// //// [commentsExternalModules_0.ts] - /** Module comment*/ export module m1 { /** b's comment*/ diff --git a/tests/baselines/reference/commentsExternalModules.symbols b/tests/baselines/reference/commentsExternalModules.symbols index 6f7852245dd5c..ab361af481c85 100644 --- a/tests/baselines/reference/commentsExternalModules.symbols +++ b/tests/baselines/reference/commentsExternalModules.symbols @@ -4,140 +4,139 @@ import extMod = require("commentsExternalModules_0"); // trailing comment1 >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) extMod.m1.fooExport(); ->extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules_0.ts, 0, 0)) ->fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) var newVar = new extMod.m1.m2.c(); >newVar : Symbol(newVar, Decl(commentsExternalModules_1.ts, 3, 3)) ->extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules_0.ts, 10, 22)) ->extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules_0.ts, 8, 5)) +>extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules_0.ts, 9, 22)) +>extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules_0.ts, 7, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules_0.ts, 0, 0)) ->m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules_0.ts, 8, 5)) ->c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules_0.ts, 10, 22)) +>m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules_0.ts, 7, 5)) +>c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules_0.ts, 9, 22)) extMod.m4.fooExport(); ->extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 23, 26)) +>extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 23, 26)) ->fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 22, 26)) +>fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) var newVar2 = new extMod.m4.m2.c(); >newVar2 : Symbol(newVar2, Decl(commentsExternalModules_1.ts, 5, 3)) ->extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules_0.ts, 36, 22)) ->extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules_0.ts, 33, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 23, 26)) +>extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules_0.ts, 35, 22)) +>extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules_0.ts, 32, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 23, 26)) ->m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules_0.ts, 33, 5)) ->c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules_0.ts, 36, 22)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules_0.ts, 22, 26)) +>m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules_0.ts, 32, 5)) +>c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules_0.ts, 35, 22)) === tests/cases/compiler/commentsExternalModules_0.ts === - /** Module comment*/ export module m1 { >m1 : Symbol(m1, Decl(commentsExternalModules_0.ts, 0, 0)) /** b's comment*/ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules_0.ts, 3, 14)) /** foo's comment*/ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 3, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules_0.ts, 3, 14)) } /** m2 comments*/ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules_0.ts, 8, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules_0.ts, 7, 5)) /** class comment;*/ export class c { ->c : Symbol(c, Decl(commentsExternalModules_0.ts, 10, 22)) +>c : Symbol(c, Decl(commentsExternalModules_0.ts, 9, 22)) }; /** i*/ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules_0.ts, 15, 18)) ->c : Symbol(c, Decl(commentsExternalModules_0.ts, 10, 22)) +>i : Symbol(i, Decl(commentsExternalModules_0.ts, 14, 18)) +>c : Symbol(c, Decl(commentsExternalModules_0.ts, 9, 22)) } /** exported function*/ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 3, 25)) } } m1.fooExport(); ->m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules_0.ts, 0, 0)) ->fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules_0.ts, 16, 5)) +>fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules_0.ts, 15, 5)) var myvar = new m1.m2.c(); ->myvar : Symbol(myvar, Decl(commentsExternalModules_0.ts, 23, 3)) ->m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules_0.ts, 10, 22)) ->m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules_0.ts, 8, 5)) +>myvar : Symbol(myvar, Decl(commentsExternalModules_0.ts, 22, 3)) +>m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules_0.ts, 9, 22)) +>m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules_0.ts, 7, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules_0.ts, 0, 0)) ->m2 : Symbol(m1.m2, Decl(commentsExternalModules_0.ts, 8, 5)) ->c : Symbol(m1.m2.c, Decl(commentsExternalModules_0.ts, 10, 22)) +>m2 : Symbol(m1.m2, Decl(commentsExternalModules_0.ts, 7, 5)) +>c : Symbol(m1.m2.c, Decl(commentsExternalModules_0.ts, 9, 22)) /** Module comment */ export module m4 { ->m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 23, 26)) +>m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 22, 26)) /** b's comment */ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules_0.ts, 27, 14)) /** foo's comment */ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 27, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules_0.ts, 27, 14)) } /** m2 comments */ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules_0.ts, 33, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules_0.ts, 32, 5)) /** class comment; */ export class c { ->c : Symbol(c, Decl(commentsExternalModules_0.ts, 36, 22)) +>c : Symbol(c, Decl(commentsExternalModules_0.ts, 35, 22)) }; /** i */ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules_0.ts, 41, 18)) ->c : Symbol(c, Decl(commentsExternalModules_0.ts, 36, 22)) +>i : Symbol(i, Decl(commentsExternalModules_0.ts, 40, 18)) +>c : Symbol(c, Decl(commentsExternalModules_0.ts, 35, 22)) } /** exported function */ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules_0.ts, 27, 25)) } } m4.fooExport(); ->m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 23, 26)) ->fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules_0.ts, 42, 5)) +>m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 22, 26)) +>fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules_0.ts, 41, 5)) var myvar2 = new m4.m2.c(); ->myvar2 : Symbol(myvar2, Decl(commentsExternalModules_0.ts, 49, 3)) ->m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules_0.ts, 36, 22)) ->m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules_0.ts, 33, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 23, 26)) ->m2 : Symbol(m4.m2, Decl(commentsExternalModules_0.ts, 33, 5)) ->c : Symbol(m4.m2.c, Decl(commentsExternalModules_0.ts, 36, 22)) +>myvar2 : Symbol(myvar2, Decl(commentsExternalModules_0.ts, 48, 3)) +>m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules_0.ts, 35, 22)) +>m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules_0.ts, 32, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules_0.ts, 22, 26)) +>m2 : Symbol(m4.m2, Decl(commentsExternalModules_0.ts, 32, 5)) +>c : Symbol(m4.m2.c, Decl(commentsExternalModules_0.ts, 35, 22)) diff --git a/tests/baselines/reference/commentsExternalModules.types b/tests/baselines/reference/commentsExternalModules.types index 56b6b338f4d5d..4515aaad61163 100644 --- a/tests/baselines/reference/commentsExternalModules.types +++ b/tests/baselines/reference/commentsExternalModules.types @@ -42,7 +42,6 @@ var newVar2 = new extMod.m4.m2.c(); >c : typeof extMod.m4.m2.c === tests/cases/compiler/commentsExternalModules_0.ts === - /** Module comment*/ export module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/commentsExternalModules2.js b/tests/baselines/reference/commentsExternalModules2.js index d06c588425fea..af1e78b692c7e 100644 --- a/tests/baselines/reference/commentsExternalModules2.js +++ b/tests/baselines/reference/commentsExternalModules2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsExternalModules2.ts] //// //// [commentsExternalModules2_0.ts] - /** Module comment*/ export module m1 { /** b's comment*/ diff --git a/tests/baselines/reference/commentsExternalModules2.symbols b/tests/baselines/reference/commentsExternalModules2.symbols index cfd01db377d85..34d6dfbd6e268 100644 --- a/tests/baselines/reference/commentsExternalModules2.symbols +++ b/tests/baselines/reference/commentsExternalModules2.symbols @@ -4,140 +4,139 @@ import extMod = require("commentsExternalModules2_0"); // trailing comment 1 >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) extMod.m1.fooExport(); ->extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) export var newVar = new extMod.m1.m2.c(); >newVar : Symbol(newVar, Decl(commentsExternalModules_1.ts, 3, 10)) ->extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) ->extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) +>extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) ->c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) +>c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) extMod.m4.fooExport(); ->extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) export var newVar2 = new extMod.m4.m2.c(); >newVar2 : Symbol(newVar2, Decl(commentsExternalModules_1.ts, 5, 10)) ->extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) ->extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) +>extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) === tests/cases/compiler/commentsExternalModules2_0.ts === - /** Module comment*/ export module m1 { >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) /** b's comment*/ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 3, 14)) /** foo's comment*/ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 3, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 3, 14)) } /** m2 comments*/ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 7, 5)) /** class comment;*/ export class c { ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 9, 22)) }; /** i*/ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules2_0.ts, 15, 18)) ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>i : Symbol(i, Decl(commentsExternalModules2_0.ts, 14, 18)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 9, 22)) } /** exported function*/ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 3, 25)) } } m1.fooExport(); ->m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) var myvar = new m1.m2.c(); ->myvar : Symbol(myvar, Decl(commentsExternalModules2_0.ts, 23, 3)) ->m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) ->m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>myvar : Symbol(myvar, Decl(commentsExternalModules2_0.ts, 22, 3)) +>m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) +>m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) ->c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) +>c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) /** Module comment */ export module m4 { ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) /** b's comment */ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 27, 14)) /** foo's comment */ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 27, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 27, 14)) } /** m2 comments */ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 33, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 32, 5)) /** class comment; */ export class c { ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 35, 22)) }; /** i */ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules2_0.ts, 41, 18)) ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>i : Symbol(i, Decl(commentsExternalModules2_0.ts, 40, 18)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 35, 22)) } /** exported function */ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 27, 25)) } } m4.fooExport(); ->m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) var myvar2 = new m4.m2.c(); ->myvar2 : Symbol(myvar2, Decl(commentsExternalModules2_0.ts, 49, 3)) ->m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) ->m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>myvar2 : Symbol(myvar2, Decl(commentsExternalModules2_0.ts, 48, 3)) +>m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) +>m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) diff --git a/tests/baselines/reference/commentsExternalModules2.types b/tests/baselines/reference/commentsExternalModules2.types index 556b5d11d35b5..9103d6abcebc0 100644 --- a/tests/baselines/reference/commentsExternalModules2.types +++ b/tests/baselines/reference/commentsExternalModules2.types @@ -42,7 +42,6 @@ export var newVar2 = new extMod.m4.m2.c(); >c : typeof extMod.m4.m2.c === tests/cases/compiler/commentsExternalModules2_0.ts === - /** Module comment*/ export module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/commentsExternalModules3.js b/tests/baselines/reference/commentsExternalModules3.js index 81e90a159d560..e830f9de7a3ca 100644 --- a/tests/baselines/reference/commentsExternalModules3.js +++ b/tests/baselines/reference/commentsExternalModules3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsExternalModules3.ts] //// //// [commentsExternalModules2_0.ts] - /** Module comment*/ export module m1 { /** b's comment*/ diff --git a/tests/baselines/reference/commentsExternalModules3.symbols b/tests/baselines/reference/commentsExternalModules3.symbols index 4cab3b0d28af2..4e74d76906d1c 100644 --- a/tests/baselines/reference/commentsExternalModules3.symbols +++ b/tests/baselines/reference/commentsExternalModules3.symbols @@ -4,140 +4,139 @@ import extMod = require("./commentsExternalModules2_0"); // trailing comment 1 >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) extMod.m1.fooExport(); ->extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>extMod.m1.fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(extMod.m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) export var newVar = new extMod.m1.m2.c(); >newVar : Symbol(newVar, Decl(commentsExternalModules_1.ts, 3, 10)) ->extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) ->extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>extMod.m1.m2.c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) +>extMod.m1.m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) >extMod.m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) >m1 : Symbol(extMod.m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) ->c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>m2 : Symbol(extMod.m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) +>c : Symbol(extMod.m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) extMod.m4.fooExport(); ->extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>extMod.m4.fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>fooExport : Symbol(extMod.m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) export var newVar2 = new extMod.m4.m2.c(); >newVar2 : Symbol(newVar2, Decl(commentsExternalModules_1.ts, 5, 10)) ->extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) ->extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>extMod.m4.m2.c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) +>extMod.m4.m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>extMod.m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0)) ->m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>m4 : Symbol(extMod.m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>m2 : Symbol(extMod.m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>c : Symbol(extMod.m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) === tests/cases/compiler/commentsExternalModules2_0.ts === - /** Module comment*/ export module m1 { >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) /** b's comment*/ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 3, 14)) /** foo's comment*/ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 3, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 4, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 3, 14)) } /** m2 comments*/ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 7, 5)) /** class comment;*/ export class c { ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 9, 22)) }; /** i*/ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules2_0.ts, 15, 18)) ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>i : Symbol(i, Decl(commentsExternalModules2_0.ts, 14, 18)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 9, 22)) } /** exported function*/ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 4, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 3, 25)) } } m1.fooExport(); ->m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>m1.fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 16, 5)) +>fooExport : Symbol(m1.fooExport, Decl(commentsExternalModules2_0.ts, 15, 5)) var myvar = new m1.m2.c(); ->myvar : Symbol(myvar, Decl(commentsExternalModules2_0.ts, 23, 3)) ->m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) ->m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) +>myvar : Symbol(myvar, Decl(commentsExternalModules2_0.ts, 22, 3)) +>m1.m2.c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) +>m1.m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) >m1 : Symbol(m1, Decl(commentsExternalModules2_0.ts, 0, 0)) ->m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 8, 5)) ->c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 10, 22)) +>m2 : Symbol(m1.m2, Decl(commentsExternalModules2_0.ts, 7, 5)) +>c : Symbol(m1.m2.c, Decl(commentsExternalModules2_0.ts, 9, 22)) /** Module comment */ export module m4 { ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) /** b's comment */ export var b: number; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 27, 14)) /** foo's comment */ function foo() { ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 27, 25)) return b; ->b : Symbol(b, Decl(commentsExternalModules2_0.ts, 28, 14)) +>b : Symbol(b, Decl(commentsExternalModules2_0.ts, 27, 14)) } /** m2 comments */ export module m2 { ->m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 33, 5)) +>m2 : Symbol(m2, Decl(commentsExternalModules2_0.ts, 32, 5)) /** class comment; */ export class c { ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 35, 22)) }; /** i */ export var i = new c(); ->i : Symbol(i, Decl(commentsExternalModules2_0.ts, 41, 18)) ->c : Symbol(c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>i : Symbol(i, Decl(commentsExternalModules2_0.ts, 40, 18)) +>c : Symbol(c, Decl(commentsExternalModules2_0.ts, 35, 22)) } /** exported function */ export function fooExport() { ->fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>fooExport : Symbol(fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) return foo(); ->foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 28, 25)) +>foo : Symbol(foo, Decl(commentsExternalModules2_0.ts, 27, 25)) } } m4.fooExport(); ->m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 42, 5)) +>m4.fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>fooExport : Symbol(m4.fooExport, Decl(commentsExternalModules2_0.ts, 41, 5)) var myvar2 = new m4.m2.c(); ->myvar2 : Symbol(myvar2, Decl(commentsExternalModules2_0.ts, 49, 3)) ->m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) ->m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 23, 26)) ->m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 33, 5)) ->c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 36, 22)) +>myvar2 : Symbol(myvar2, Decl(commentsExternalModules2_0.ts, 48, 3)) +>m4.m2.c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) +>m4.m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>m4 : Symbol(m4, Decl(commentsExternalModules2_0.ts, 22, 26)) +>m2 : Symbol(m4.m2, Decl(commentsExternalModules2_0.ts, 32, 5)) +>c : Symbol(m4.m2.c, Decl(commentsExternalModules2_0.ts, 35, 22)) diff --git a/tests/baselines/reference/commentsExternalModules3.types b/tests/baselines/reference/commentsExternalModules3.types index 2898784b7eaa3..203e9923676aa 100644 --- a/tests/baselines/reference/commentsExternalModules3.types +++ b/tests/baselines/reference/commentsExternalModules3.types @@ -42,7 +42,6 @@ export var newVar2 = new extMod.m4.m2.c(); >c : typeof extMod.m4.m2.c === tests/cases/compiler/commentsExternalModules2_0.ts === - /** Module comment*/ export module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/commentsFormatting.js b/tests/baselines/reference/commentsFormatting.js index cfee157eada66..a754fe9bb85d6 100644 --- a/tests/baselines/reference/commentsFormatting.js +++ b/tests/baselines/reference/commentsFormatting.js @@ -1,5 +1,4 @@ //// [commentsFormatting.ts] - module m { /** this is first line - aligned to class declaration * this is 4 spaces left aligned diff --git a/tests/baselines/reference/commentsFormatting.symbols b/tests/baselines/reference/commentsFormatting.symbols index a858d48ce67e2..51cedb6251a1a 100644 --- a/tests/baselines/reference/commentsFormatting.symbols +++ b/tests/baselines/reference/commentsFormatting.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsFormatting.ts === - module m { >m : Symbol(m, Decl(commentsFormatting.ts, 0, 0)) @@ -18,7 +17,7 @@ module m { * this is 7 spaces right aligned * this is 8 spaces right aligned */ export class c { ->c : Symbol(c, Decl(commentsFormatting.ts, 1, 10)) +>c : Symbol(c, Decl(commentsFormatting.ts, 0, 10)) } /** this is first line - 4 spaces right aligned to class but in js file should be aligned to class declaration @@ -40,7 +39,7 @@ module m { * this is 7 spaces right aligned * this is 8 spaces right aligned */ export class c2 { ->c2 : Symbol(c2, Decl(commentsFormatting.ts, 17, 5)) +>c2 : Symbol(c2, Decl(commentsFormatting.ts, 16, 5)) } /** this is comment with new lines in between @@ -70,7 +69,7 @@ this is 4 spaces left aligned but above line is empty above 3 lines are empty*/ export class c3 { ->c3 : Symbol(c3, Decl(commentsFormatting.ts, 38, 5)) +>c3 : Symbol(c3, Decl(commentsFormatting.ts, 37, 5)) } /** this is first line - aligned to class declaration @@ -88,6 +87,6 @@ this is 4 spaces left aligned but above line is empty * this is 11 spaces + tab * this is 12 spaces + tab */ export class c4 { ->c4 : Symbol(c4, Decl(commentsFormatting.ts, 67, 5)) +>c4 : Symbol(c4, Decl(commentsFormatting.ts, 66, 5)) } } diff --git a/tests/baselines/reference/commentsFormatting.types b/tests/baselines/reference/commentsFormatting.types index 2de53654f9e40..475de87b8a67b 100644 --- a/tests/baselines/reference/commentsFormatting.types +++ b/tests/baselines/reference/commentsFormatting.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsFormatting.ts === - module m { >m : typeof m diff --git a/tests/baselines/reference/commentsFunction.js b/tests/baselines/reference/commentsFunction.js index d9e9ccd15eae4..ad31aa47b9140 100644 --- a/tests/baselines/reference/commentsFunction.js +++ b/tests/baselines/reference/commentsFunction.js @@ -1,5 +1,4 @@ //// [commentsFunction.ts] - /** This comment should appear for foo*/ function foo() { } /* trailing comment of function */ diff --git a/tests/baselines/reference/commentsFunction.symbols b/tests/baselines/reference/commentsFunction.symbols index dfc68eb6743e1..c4860ec0506b9 100644 --- a/tests/baselines/reference/commentsFunction.symbols +++ b/tests/baselines/reference/commentsFunction.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsFunction.ts === - /** This comment should appear for foo*/ function foo() { >foo : Symbol(foo, Decl(commentsFunction.ts, 0, 0)) @@ -10,97 +9,97 @@ foo(); /** This is comment for function signature*/ function fooWithParameters(/** this is comment about a*/a: string, ->fooWithParameters : Symbol(fooWithParameters, Decl(commentsFunction.ts, 4, 6)) ->a : Symbol(a, Decl(commentsFunction.ts, 6, 27)) +>fooWithParameters : Symbol(fooWithParameters, Decl(commentsFunction.ts, 3, 6)) +>a : Symbol(a, Decl(commentsFunction.ts, 5, 27)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(commentsFunction.ts, 6, 66)) +>b : Symbol(b, Decl(commentsFunction.ts, 5, 66)) var d = a; ->d : Symbol(d, Decl(commentsFunction.ts, 9, 7)) ->a : Symbol(a, Decl(commentsFunction.ts, 6, 27)) +>d : Symbol(d, Decl(commentsFunction.ts, 8, 7)) +>a : Symbol(a, Decl(commentsFunction.ts, 5, 27)) } // trailing comment of function fooWithParameters("a", 10); ->fooWithParameters : Symbol(fooWithParameters, Decl(commentsFunction.ts, 4, 6)) +>fooWithParameters : Symbol(fooWithParameters, Decl(commentsFunction.ts, 3, 6)) /** fooFunc * comment */ var fooFunc = function FooFunctionValue(/** fooFunctionValue param */ b: string) { ->fooFunc : Symbol(fooFunc, Decl(commentsFunction.ts, 15, 3)) ->FooFunctionValue : Symbol(FooFunctionValue, Decl(commentsFunction.ts, 15, 13)) ->b : Symbol(b, Decl(commentsFunction.ts, 15, 40)) +>fooFunc : Symbol(fooFunc, Decl(commentsFunction.ts, 14, 3)) +>FooFunctionValue : Symbol(FooFunctionValue, Decl(commentsFunction.ts, 14, 13)) +>b : Symbol(b, Decl(commentsFunction.ts, 14, 40)) return b; ->b : Symbol(b, Decl(commentsFunction.ts, 15, 40)) +>b : Symbol(b, Decl(commentsFunction.ts, 14, 40)) } /// lamdaFoo var comment var lambdaFoo = /** this is lambda comment*/ (/**param a*/a: number, /**param b*/b: number) => a + b; ->lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3)) ->a : Symbol(a, Decl(commentsFunction.ts, 20, 46)) ->b : Symbol(b, Decl(commentsFunction.ts, 20, 68)) ->a : Symbol(a, Decl(commentsFunction.ts, 20, 46)) ->b : Symbol(b, Decl(commentsFunction.ts, 20, 68)) +>lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 19, 3)) +>a : Symbol(a, Decl(commentsFunction.ts, 19, 46)) +>b : Symbol(b, Decl(commentsFunction.ts, 19, 68)) +>a : Symbol(a, Decl(commentsFunction.ts, 19, 46)) +>b : Symbol(b, Decl(commentsFunction.ts, 19, 68)) var lambddaNoVarComment = /** this is lambda multiplication*/ (/**param a*/a: number, /**param b*/b: number) => a * b; ->lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 21, 3)) ->a : Symbol(a, Decl(commentsFunction.ts, 21, 63)) ->b : Symbol(b, Decl(commentsFunction.ts, 21, 85)) ->a : Symbol(a, Decl(commentsFunction.ts, 21, 63)) ->b : Symbol(b, Decl(commentsFunction.ts, 21, 85)) +>lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 20, 3)) +>a : Symbol(a, Decl(commentsFunction.ts, 20, 63)) +>b : Symbol(b, Decl(commentsFunction.ts, 20, 85)) +>a : Symbol(a, Decl(commentsFunction.ts, 20, 63)) +>b : Symbol(b, Decl(commentsFunction.ts, 20, 85)) lambdaFoo(10, 20); ->lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3)) +>lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 19, 3)) lambddaNoVarComment(10, 20); ->lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 21, 3)) +>lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 20, 3)) function blah(a: string /* multiline trailing comment ->blah : Symbol(blah, Decl(commentsFunction.ts, 23, 28)) ->a : Symbol(a, Decl(commentsFunction.ts, 25, 14)) +>blah : Symbol(blah, Decl(commentsFunction.ts, 22, 28)) +>a : Symbol(a, Decl(commentsFunction.ts, 24, 14)) multiline */) { } function blah2(a: string /* single line multiple trailing comments */ /* second */) { ->blah2 : Symbol(blah2, Decl(commentsFunction.ts, 27, 1)) ->a : Symbol(a, Decl(commentsFunction.ts, 29, 15)) +>blah2 : Symbol(blah2, Decl(commentsFunction.ts, 26, 1)) +>a : Symbol(a, Decl(commentsFunction.ts, 28, 15)) } function blah3(a: string // trailing commen single line ->blah3 : Symbol(blah3, Decl(commentsFunction.ts, 30, 1)) ->a : Symbol(a, Decl(commentsFunction.ts, 32, 15)) +>blah3 : Symbol(blah3, Decl(commentsFunction.ts, 29, 1)) +>a : Symbol(a, Decl(commentsFunction.ts, 31, 15)) ) { } lambdaFoo = (a, b) => a * b; // This is trailing comment ->lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3)) ->a : Symbol(a, Decl(commentsFunction.ts, 36, 13)) ->b : Symbol(b, Decl(commentsFunction.ts, 36, 15)) ->a : Symbol(a, Decl(commentsFunction.ts, 36, 13)) ->b : Symbol(b, Decl(commentsFunction.ts, 36, 15)) +>lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 19, 3)) +>a : Symbol(a, Decl(commentsFunction.ts, 35, 13)) +>b : Symbol(b, Decl(commentsFunction.ts, 35, 15)) +>a : Symbol(a, Decl(commentsFunction.ts, 35, 13)) +>b : Symbol(b, Decl(commentsFunction.ts, 35, 15)) /*leading comment*/() => 0; // Needs to be wrapped in parens to be a valid expression (not declaration) /*leading comment*/(() => 0); //trailing comment function blah4(/*1*/a: string/*2*/,/*3*/b: string/*4*/) { ->blah4 : Symbol(blah4, Decl(commentsFunction.ts, 39, 29)) ->a : Symbol(a, Decl(commentsFunction.ts, 41, 15)) ->b : Symbol(b, Decl(commentsFunction.ts, 41, 35)) +>blah4 : Symbol(blah4, Decl(commentsFunction.ts, 38, 29)) +>a : Symbol(a, Decl(commentsFunction.ts, 40, 15)) +>b : Symbol(b, Decl(commentsFunction.ts, 40, 35)) } function foo1() { ->foo1 : Symbol(foo1, Decl(commentsFunction.ts, 42, 1)) +>foo1 : Symbol(foo1, Decl(commentsFunction.ts, 41, 1)) // should emit this } function foo2() { ->foo2 : Symbol(foo2, Decl(commentsFunction.ts, 47, 1)) +>foo2 : Symbol(foo2, Decl(commentsFunction.ts, 46, 1)) /// This is some detached comment diff --git a/tests/baselines/reference/commentsFunction.types b/tests/baselines/reference/commentsFunction.types index 75a6cb6eaaf4a..bf25fb585750a 100644 --- a/tests/baselines/reference/commentsFunction.types +++ b/tests/baselines/reference/commentsFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsFunction.ts === - /** This comment should appear for foo*/ function foo() { >foo : () => void diff --git a/tests/baselines/reference/commentsInheritance.js b/tests/baselines/reference/commentsInheritance.js index 53fcab2cf3f3c..e33a4244c037d 100644 --- a/tests/baselines/reference/commentsInheritance.js +++ b/tests/baselines/reference/commentsInheritance.js @@ -1,5 +1,4 @@ //// [commentsInheritance.ts] - /** i1 is interface with properties*/ interface i1 { /** i1_p1*/ diff --git a/tests/baselines/reference/commentsInheritance.symbols b/tests/baselines/reference/commentsInheritance.symbols index 288bfdb4280e7..d5880ad4b26f8 100644 --- a/tests/baselines/reference/commentsInheritance.symbols +++ b/tests/baselines/reference/commentsInheritance.symbols @@ -1,311 +1,310 @@ === tests/cases/compiler/commentsInheritance.ts === - /** i1 is interface with properties*/ interface i1 { >i1 : Symbol(i1, Decl(commentsInheritance.ts, 0, 0)) /** i1_p1*/ i1_p1: number; ->i1_p1 : Symbol(i1.i1_p1, Decl(commentsInheritance.ts, 2, 14)) +>i1_p1 : Symbol(i1.i1_p1, Decl(commentsInheritance.ts, 1, 14)) /** i1_f1*/ i1_f1(): void; ->i1_f1 : Symbol(i1.i1_f1, Decl(commentsInheritance.ts, 4, 18)) +>i1_f1 : Symbol(i1.i1_f1, Decl(commentsInheritance.ts, 3, 18)) /** i1_l1*/ i1_l1: () => void; ->i1_l1 : Symbol(i1.i1_l1, Decl(commentsInheritance.ts, 6, 18)) +>i1_l1 : Symbol(i1.i1_l1, Decl(commentsInheritance.ts, 5, 18)) // il_nc_p1 i1_nc_p1: number; ->i1_nc_p1 : Symbol(i1.i1_nc_p1, Decl(commentsInheritance.ts, 8, 22)) +>i1_nc_p1 : Symbol(i1.i1_nc_p1, Decl(commentsInheritance.ts, 7, 22)) i1_nc_f1(): void; ->i1_nc_f1 : Symbol(i1.i1_nc_f1, Decl(commentsInheritance.ts, 10, 21)) +>i1_nc_f1 : Symbol(i1.i1_nc_f1, Decl(commentsInheritance.ts, 9, 21)) i1_nc_l1: () => void; ->i1_nc_l1 : Symbol(i1.i1_nc_l1, Decl(commentsInheritance.ts, 11, 21)) +>i1_nc_l1 : Symbol(i1.i1_nc_l1, Decl(commentsInheritance.ts, 10, 21)) p1: number; ->p1 : Symbol(i1.p1, Decl(commentsInheritance.ts, 12, 25)) +>p1 : Symbol(i1.p1, Decl(commentsInheritance.ts, 11, 25)) f1(): void; ->f1 : Symbol(i1.f1, Decl(commentsInheritance.ts, 13, 15)) +>f1 : Symbol(i1.f1, Decl(commentsInheritance.ts, 12, 15)) l1: () => void; ->l1 : Symbol(i1.l1, Decl(commentsInheritance.ts, 14, 15)) +>l1 : Symbol(i1.l1, Decl(commentsInheritance.ts, 13, 15)) nc_p1: number; ->nc_p1 : Symbol(i1.nc_p1, Decl(commentsInheritance.ts, 15, 19)) +>nc_p1 : Symbol(i1.nc_p1, Decl(commentsInheritance.ts, 14, 19)) nc_f1(): void; ->nc_f1 : Symbol(i1.nc_f1, Decl(commentsInheritance.ts, 16, 18)) +>nc_f1 : Symbol(i1.nc_f1, Decl(commentsInheritance.ts, 15, 18)) nc_l1: () => void; ->nc_l1 : Symbol(i1.nc_l1, Decl(commentsInheritance.ts, 17, 18)) +>nc_l1 : Symbol(i1.nc_l1, Decl(commentsInheritance.ts, 16, 18)) } class c1 implements i1 { ->c1 : Symbol(c1, Decl(commentsInheritance.ts, 19, 1)) +>c1 : Symbol(c1, Decl(commentsInheritance.ts, 18, 1)) >i1 : Symbol(i1, Decl(commentsInheritance.ts, 0, 0)) public i1_p1: number; ->i1_p1 : Symbol(c1.i1_p1, Decl(commentsInheritance.ts, 20, 24)) +>i1_p1 : Symbol(c1.i1_p1, Decl(commentsInheritance.ts, 19, 24)) // i1_f1 public i1_f1() { ->i1_f1 : Symbol(c1.i1_f1, Decl(commentsInheritance.ts, 21, 25)) +>i1_f1 : Symbol(c1.i1_f1, Decl(commentsInheritance.ts, 20, 25)) } public i1_l1: () => void; ->i1_l1 : Symbol(c1.i1_l1, Decl(commentsInheritance.ts, 24, 5)) +>i1_l1 : Symbol(c1.i1_l1, Decl(commentsInheritance.ts, 23, 5)) public i1_nc_p1: number; ->i1_nc_p1 : Symbol(c1.i1_nc_p1, Decl(commentsInheritance.ts, 25, 29)) +>i1_nc_p1 : Symbol(c1.i1_nc_p1, Decl(commentsInheritance.ts, 24, 29)) public i1_nc_f1() { ->i1_nc_f1 : Symbol(c1.i1_nc_f1, Decl(commentsInheritance.ts, 26, 28)) +>i1_nc_f1 : Symbol(c1.i1_nc_f1, Decl(commentsInheritance.ts, 25, 28)) } public i1_nc_l1: () => void; ->i1_nc_l1 : Symbol(c1.i1_nc_l1, Decl(commentsInheritance.ts, 28, 5)) +>i1_nc_l1 : Symbol(c1.i1_nc_l1, Decl(commentsInheritance.ts, 27, 5)) /** c1_p1*/ public p1: number; ->p1 : Symbol(c1.p1, Decl(commentsInheritance.ts, 29, 32)) +>p1 : Symbol(c1.p1, Decl(commentsInheritance.ts, 28, 32)) /** c1_f1*/ public f1() { ->f1 : Symbol(c1.f1, Decl(commentsInheritance.ts, 31, 22)) +>f1 : Symbol(c1.f1, Decl(commentsInheritance.ts, 30, 22)) } /** c1_l1*/ public l1: () => void; ->l1 : Symbol(c1.l1, Decl(commentsInheritance.ts, 34, 5)) +>l1 : Symbol(c1.l1, Decl(commentsInheritance.ts, 33, 5)) /** c1_nc_p1*/ public nc_p1: number; ->nc_p1 : Symbol(c1.nc_p1, Decl(commentsInheritance.ts, 36, 26)) +>nc_p1 : Symbol(c1.nc_p1, Decl(commentsInheritance.ts, 35, 26)) /** c1_nc_f1*/ public nc_f1() { ->nc_f1 : Symbol(c1.nc_f1, Decl(commentsInheritance.ts, 38, 25)) +>nc_f1 : Symbol(c1.nc_f1, Decl(commentsInheritance.ts, 37, 25)) } /** c1_nc_l1*/ public nc_l1: () => void; ->nc_l1 : Symbol(c1.nc_l1, Decl(commentsInheritance.ts, 41, 5)) +>nc_l1 : Symbol(c1.nc_l1, Decl(commentsInheritance.ts, 40, 5)) } var i1_i: i1; ->i1_i : Symbol(i1_i, Decl(commentsInheritance.ts, 45, 3)) +>i1_i : Symbol(i1_i, Decl(commentsInheritance.ts, 44, 3)) >i1 : Symbol(i1, Decl(commentsInheritance.ts, 0, 0)) var c1_i = new c1(); ->c1_i : Symbol(c1_i, Decl(commentsInheritance.ts, 46, 3)) ->c1 : Symbol(c1, Decl(commentsInheritance.ts, 19, 1)) +>c1_i : Symbol(c1_i, Decl(commentsInheritance.ts, 45, 3)) +>c1 : Symbol(c1, Decl(commentsInheritance.ts, 18, 1)) // assign to interface i1_i = c1_i; ->i1_i : Symbol(i1_i, Decl(commentsInheritance.ts, 45, 3)) ->c1_i : Symbol(c1_i, Decl(commentsInheritance.ts, 46, 3)) +>i1_i : Symbol(i1_i, Decl(commentsInheritance.ts, 44, 3)) +>c1_i : Symbol(c1_i, Decl(commentsInheritance.ts, 45, 3)) class c2 { ->c2 : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>c2 : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) /** c2 c2_p1*/ public c2_p1: number; ->c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 49, 10)) +>c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 48, 10)) /** c2 c2_f1*/ public c2_f1() { ->c2_f1 : Symbol(c2.c2_f1, Decl(commentsInheritance.ts, 51, 25)) +>c2_f1 : Symbol(c2.c2_f1, Decl(commentsInheritance.ts, 50, 25)) } /** c2 c2_prop*/ public get c2_prop() { ->c2_prop : Symbol(c2.c2_prop, Decl(commentsInheritance.ts, 54, 5)) +>c2_prop : Symbol(c2.c2_prop, Decl(commentsInheritance.ts, 53, 5)) return 10; } public c2_nc_p1: number; ->c2_nc_p1 : Symbol(c2.c2_nc_p1, Decl(commentsInheritance.ts, 58, 5)) +>c2_nc_p1 : Symbol(c2.c2_nc_p1, Decl(commentsInheritance.ts, 57, 5)) public c2_nc_f1() { ->c2_nc_f1 : Symbol(c2.c2_nc_f1, Decl(commentsInheritance.ts, 59, 28)) +>c2_nc_f1 : Symbol(c2.c2_nc_f1, Decl(commentsInheritance.ts, 58, 28)) } public get c2_nc_prop() { ->c2_nc_prop : Symbol(c2.c2_nc_prop, Decl(commentsInheritance.ts, 61, 5)) +>c2_nc_prop : Symbol(c2.c2_nc_prop, Decl(commentsInheritance.ts, 60, 5)) return 10; } /** c2 p1*/ public p1: number; ->p1 : Symbol(c2.p1, Decl(commentsInheritance.ts, 64, 5)) +>p1 : Symbol(c2.p1, Decl(commentsInheritance.ts, 63, 5)) /** c2 f1*/ public f1() { ->f1 : Symbol(c2.f1, Decl(commentsInheritance.ts, 66, 22)) +>f1 : Symbol(c2.f1, Decl(commentsInheritance.ts, 65, 22)) } /** c2 prop*/ public get prop() { ->prop : Symbol(c2.prop, Decl(commentsInheritance.ts, 69, 5)) +>prop : Symbol(c2.prop, Decl(commentsInheritance.ts, 68, 5)) return 10; } public nc_p1: number; ->nc_p1 : Symbol(c2.nc_p1, Decl(commentsInheritance.ts, 73, 5)) +>nc_p1 : Symbol(c2.nc_p1, Decl(commentsInheritance.ts, 72, 5)) public nc_f1() { ->nc_f1 : Symbol(c2.nc_f1, Decl(commentsInheritance.ts, 74, 25)) +>nc_f1 : Symbol(c2.nc_f1, Decl(commentsInheritance.ts, 73, 25)) } public get nc_prop() { ->nc_prop : Symbol(c2.nc_prop, Decl(commentsInheritance.ts, 76, 5)) +>nc_prop : Symbol(c2.nc_prop, Decl(commentsInheritance.ts, 75, 5)) return 10; } /** c2 constructor*/ constructor(a: number) { ->a : Symbol(a, Decl(commentsInheritance.ts, 81, 16)) +>a : Symbol(a, Decl(commentsInheritance.ts, 80, 16)) this.c2_p1 = a; ->this.c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 49, 10)) ->this : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) ->c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 49, 10)) ->a : Symbol(a, Decl(commentsInheritance.ts, 81, 16)) +>this.c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 48, 10)) +>this : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) +>c2_p1 : Symbol(c2.c2_p1, Decl(commentsInheritance.ts, 48, 10)) +>a : Symbol(a, Decl(commentsInheritance.ts, 80, 16)) } } class c3 extends c2 { ->c3 : Symbol(c3, Decl(commentsInheritance.ts, 84, 1)) ->c2 : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>c3 : Symbol(c3, Decl(commentsInheritance.ts, 83, 1)) +>c2 : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) constructor() { super(10); ->super : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>super : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) } /** c3 p1*/ public p1: number; ->p1 : Symbol(c3.p1, Decl(commentsInheritance.ts, 88, 5)) +>p1 : Symbol(c3.p1, Decl(commentsInheritance.ts, 87, 5)) /** c3 f1*/ public f1() { ->f1 : Symbol(c3.f1, Decl(commentsInheritance.ts, 90, 22)) +>f1 : Symbol(c3.f1, Decl(commentsInheritance.ts, 89, 22)) } /** c3 prop*/ public get prop() { ->prop : Symbol(c3.prop, Decl(commentsInheritance.ts, 93, 5)) +>prop : Symbol(c3.prop, Decl(commentsInheritance.ts, 92, 5)) return 10; } public nc_p1: number; ->nc_p1 : Symbol(c3.nc_p1, Decl(commentsInheritance.ts, 97, 5)) +>nc_p1 : Symbol(c3.nc_p1, Decl(commentsInheritance.ts, 96, 5)) public nc_f1() { ->nc_f1 : Symbol(c3.nc_f1, Decl(commentsInheritance.ts, 98, 25)) +>nc_f1 : Symbol(c3.nc_f1, Decl(commentsInheritance.ts, 97, 25)) } public get nc_prop() { ->nc_prop : Symbol(c3.nc_prop, Decl(commentsInheritance.ts, 100, 5)) +>nc_prop : Symbol(c3.nc_prop, Decl(commentsInheritance.ts, 99, 5)) return 10; } } var c2_i = new c2(10); ->c2_i : Symbol(c2_i, Decl(commentsInheritance.ts, 105, 3)) ->c2 : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>c2_i : Symbol(c2_i, Decl(commentsInheritance.ts, 104, 3)) +>c2 : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) var c3_i = new c3(); ->c3_i : Symbol(c3_i, Decl(commentsInheritance.ts, 106, 3)) ->c3 : Symbol(c3, Decl(commentsInheritance.ts, 84, 1)) +>c3_i : Symbol(c3_i, Decl(commentsInheritance.ts, 105, 3)) +>c3 : Symbol(c3, Decl(commentsInheritance.ts, 83, 1)) // assign c2_i = c3_i; ->c2_i : Symbol(c2_i, Decl(commentsInheritance.ts, 105, 3)) ->c3_i : Symbol(c3_i, Decl(commentsInheritance.ts, 106, 3)) +>c2_i : Symbol(c2_i, Decl(commentsInheritance.ts, 104, 3)) +>c3_i : Symbol(c3_i, Decl(commentsInheritance.ts, 105, 3)) class c4 extends c2 { ->c4 : Symbol(c4, Decl(commentsInheritance.ts, 108, 12)) ->c2 : Symbol(c2, Decl(commentsInheritance.ts, 48, 12)) +>c4 : Symbol(c4, Decl(commentsInheritance.ts, 107, 12)) +>c2 : Symbol(c2, Decl(commentsInheritance.ts, 47, 12)) } var c4_i = new c4(10); ->c4_i : Symbol(c4_i, Decl(commentsInheritance.ts, 111, 3)) ->c4 : Symbol(c4, Decl(commentsInheritance.ts, 108, 12)) +>c4_i : Symbol(c4_i, Decl(commentsInheritance.ts, 110, 3)) +>c4 : Symbol(c4, Decl(commentsInheritance.ts, 107, 12)) interface i2 { ->i2 : Symbol(i2, Decl(commentsInheritance.ts, 111, 22)) +>i2 : Symbol(i2, Decl(commentsInheritance.ts, 110, 22)) /** i2_p1*/ i2_p1: number; ->i2_p1 : Symbol(i2.i2_p1, Decl(commentsInheritance.ts, 112, 14)) +>i2_p1 : Symbol(i2.i2_p1, Decl(commentsInheritance.ts, 111, 14)) /** i2_f1*/ i2_f1(): void; ->i2_f1 : Symbol(i2.i2_f1, Decl(commentsInheritance.ts, 114, 18)) +>i2_f1 : Symbol(i2.i2_f1, Decl(commentsInheritance.ts, 113, 18)) /** i2_l1*/ i2_l1: () => void; ->i2_l1 : Symbol(i2.i2_l1, Decl(commentsInheritance.ts, 116, 18)) +>i2_l1 : Symbol(i2.i2_l1, Decl(commentsInheritance.ts, 115, 18)) // i2_nc_p1 i2_nc_p1: number; ->i2_nc_p1 : Symbol(i2.i2_nc_p1, Decl(commentsInheritance.ts, 118, 22)) +>i2_nc_p1 : Symbol(i2.i2_nc_p1, Decl(commentsInheritance.ts, 117, 22)) i2_nc_f1(): void; ->i2_nc_f1 : Symbol(i2.i2_nc_f1, Decl(commentsInheritance.ts, 120, 21)) +>i2_nc_f1 : Symbol(i2.i2_nc_f1, Decl(commentsInheritance.ts, 119, 21)) i2_nc_l1: () => void; ->i2_nc_l1 : Symbol(i2.i2_nc_l1, Decl(commentsInheritance.ts, 121, 21)) +>i2_nc_l1 : Symbol(i2.i2_nc_l1, Decl(commentsInheritance.ts, 120, 21)) /** i2 p1*/ p1: number; ->p1 : Symbol(i2.p1, Decl(commentsInheritance.ts, 122, 25)) +>p1 : Symbol(i2.p1, Decl(commentsInheritance.ts, 121, 25)) /** i2 f1*/ f1(): void; ->f1 : Symbol(i2.f1, Decl(commentsInheritance.ts, 124, 15)) +>f1 : Symbol(i2.f1, Decl(commentsInheritance.ts, 123, 15)) /** i2 l1*/ l1: () => void; ->l1 : Symbol(i2.l1, Decl(commentsInheritance.ts, 126, 15)) +>l1 : Symbol(i2.l1, Decl(commentsInheritance.ts, 125, 15)) nc_p1: number; ->nc_p1 : Symbol(i2.nc_p1, Decl(commentsInheritance.ts, 128, 19)) +>nc_p1 : Symbol(i2.nc_p1, Decl(commentsInheritance.ts, 127, 19)) nc_f1(): void; ->nc_f1 : Symbol(i2.nc_f1, Decl(commentsInheritance.ts, 129, 18)) +>nc_f1 : Symbol(i2.nc_f1, Decl(commentsInheritance.ts, 128, 18)) nc_l1: () => void; ->nc_l1 : Symbol(i2.nc_l1, Decl(commentsInheritance.ts, 130, 18)) +>nc_l1 : Symbol(i2.nc_l1, Decl(commentsInheritance.ts, 129, 18)) } interface i3 extends i2 { ->i3 : Symbol(i3, Decl(commentsInheritance.ts, 132, 1)) ->i2 : Symbol(i2, Decl(commentsInheritance.ts, 111, 22)) +>i3 : Symbol(i3, Decl(commentsInheritance.ts, 131, 1)) +>i2 : Symbol(i2, Decl(commentsInheritance.ts, 110, 22)) /** i3 p1 */ p1: number; ->p1 : Symbol(i3.p1, Decl(commentsInheritance.ts, 133, 25)) +>p1 : Symbol(i3.p1, Decl(commentsInheritance.ts, 132, 25)) /** * i3 f1 */ f1(): void; ->f1 : Symbol(i3.f1, Decl(commentsInheritance.ts, 135, 15)) +>f1 : Symbol(i3.f1, Decl(commentsInheritance.ts, 134, 15)) /** i3 l1*/ l1: () => void; ->l1 : Symbol(i3.l1, Decl(commentsInheritance.ts, 139, 15)) +>l1 : Symbol(i3.l1, Decl(commentsInheritance.ts, 138, 15)) nc_p1: number; ->nc_p1 : Symbol(i3.nc_p1, Decl(commentsInheritance.ts, 141, 19)) +>nc_p1 : Symbol(i3.nc_p1, Decl(commentsInheritance.ts, 140, 19)) nc_f1(): void; ->nc_f1 : Symbol(i3.nc_f1, Decl(commentsInheritance.ts, 142, 18)) +>nc_f1 : Symbol(i3.nc_f1, Decl(commentsInheritance.ts, 141, 18)) nc_l1: () => void; ->nc_l1 : Symbol(i3.nc_l1, Decl(commentsInheritance.ts, 143, 18)) +>nc_l1 : Symbol(i3.nc_l1, Decl(commentsInheritance.ts, 142, 18)) } var i2_i: i2; ->i2_i : Symbol(i2_i, Decl(commentsInheritance.ts, 146, 3)) ->i2 : Symbol(i2, Decl(commentsInheritance.ts, 111, 22)) +>i2_i : Symbol(i2_i, Decl(commentsInheritance.ts, 145, 3)) +>i2 : Symbol(i2, Decl(commentsInheritance.ts, 110, 22)) var i3_i: i3; ->i3_i : Symbol(i3_i, Decl(commentsInheritance.ts, 147, 3)) ->i3 : Symbol(i3, Decl(commentsInheritance.ts, 132, 1)) +>i3_i : Symbol(i3_i, Decl(commentsInheritance.ts, 146, 3)) +>i3 : Symbol(i3, Decl(commentsInheritance.ts, 131, 1)) // assign to interface i2_i = i3_i; ->i2_i : Symbol(i2_i, Decl(commentsInheritance.ts, 146, 3)) ->i3_i : Symbol(i3_i, Decl(commentsInheritance.ts, 147, 3)) +>i2_i : Symbol(i2_i, Decl(commentsInheritance.ts, 145, 3)) +>i3_i : Symbol(i3_i, Decl(commentsInheritance.ts, 146, 3)) diff --git a/tests/baselines/reference/commentsInheritance.types b/tests/baselines/reference/commentsInheritance.types index 804da3fd76019..a6fbc449fc109 100644 --- a/tests/baselines/reference/commentsInheritance.types +++ b/tests/baselines/reference/commentsInheritance.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsInheritance.ts === - /** i1 is interface with properties*/ interface i1 { >i1 : i1 diff --git a/tests/baselines/reference/commentsMultiModuleMultiFile.js b/tests/baselines/reference/commentsMultiModuleMultiFile.js index 25dd8a907808a..6aaace19afc5e 100644 --- a/tests/baselines/reference/commentsMultiModuleMultiFile.js +++ b/tests/baselines/reference/commentsMultiModuleMultiFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsMultiModuleMultiFile.ts] //// //// [commentsMultiModuleMultiFile_0.ts] - /** this is multi declare module*/ export module multiM { /// class b comment diff --git a/tests/baselines/reference/commentsMultiModuleMultiFile.symbols b/tests/baselines/reference/commentsMultiModuleMultiFile.symbols index 1ca90840af4f9..87f0fe5021298 100644 --- a/tests/baselines/reference/commentsMultiModuleMultiFile.symbols +++ b/tests/baselines/reference/commentsMultiModuleMultiFile.symbols @@ -22,38 +22,37 @@ new multiM.d(); >d : Symbol(multiM.d, Decl(commentsMultiModuleMultiFile_1.ts, 2, 22)) === tests/cases/compiler/commentsMultiModuleMultiFile_0.ts === - /** this is multi declare module*/ export module multiM { ->multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 6, 1)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 5, 1)) /// class b comment export class b { ->b : Symbol(b, Decl(commentsMultiModuleMultiFile_0.ts, 2, 22)) +>b : Symbol(b, Decl(commentsMultiModuleMultiFile_0.ts, 1, 22)) } } /** thi is multi module 2*/ export module multiM { ->multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 6, 1)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 5, 1)) /** class c comment*/ export class c { ->c : Symbol(c, Decl(commentsMultiModuleMultiFile_0.ts, 8, 22)) +>c : Symbol(c, Decl(commentsMultiModuleMultiFile_0.ts, 7, 22)) } // class e comment export class e { ->e : Symbol(e, Decl(commentsMultiModuleMultiFile_0.ts, 11, 5)) +>e : Symbol(e, Decl(commentsMultiModuleMultiFile_0.ts, 10, 5)) } } new multiM.b(); ->multiM.b : Symbol(multiM.b, Decl(commentsMultiModuleMultiFile_0.ts, 2, 22)) ->multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 6, 1)) ->b : Symbol(multiM.b, Decl(commentsMultiModuleMultiFile_0.ts, 2, 22)) +>multiM.b : Symbol(multiM.b, Decl(commentsMultiModuleMultiFile_0.ts, 1, 22)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 5, 1)) +>b : Symbol(multiM.b, Decl(commentsMultiModuleMultiFile_0.ts, 1, 22)) new multiM.c(); ->multiM.c : Symbol(multiM.c, Decl(commentsMultiModuleMultiFile_0.ts, 8, 22)) ->multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 6, 1)) ->c : Symbol(multiM.c, Decl(commentsMultiModuleMultiFile_0.ts, 8, 22)) +>multiM.c : Symbol(multiM.c, Decl(commentsMultiModuleMultiFile_0.ts, 7, 22)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleMultiFile_0.ts, 0, 0), Decl(commentsMultiModuleMultiFile_0.ts, 5, 1)) +>c : Symbol(multiM.c, Decl(commentsMultiModuleMultiFile_0.ts, 7, 22)) diff --git a/tests/baselines/reference/commentsMultiModuleMultiFile.types b/tests/baselines/reference/commentsMultiModuleMultiFile.types index c0f3fb1b8756d..fef48659b2ac2 100644 --- a/tests/baselines/reference/commentsMultiModuleMultiFile.types +++ b/tests/baselines/reference/commentsMultiModuleMultiFile.types @@ -23,7 +23,6 @@ new multiM.d(); >d : typeof multiM.d === tests/cases/compiler/commentsMultiModuleMultiFile_0.ts === - /** this is multi declare module*/ export module multiM { >multiM : typeof multiM diff --git a/tests/baselines/reference/commentsMultiModuleSingleFile.js b/tests/baselines/reference/commentsMultiModuleSingleFile.js index 0e00a3eaff6ae..34e693b34db87 100644 --- a/tests/baselines/reference/commentsMultiModuleSingleFile.js +++ b/tests/baselines/reference/commentsMultiModuleSingleFile.js @@ -1,5 +1,4 @@ //// [commentsMultiModuleSingleFile.ts] - /** this is multi declare module*/ module multiM { /** class b*/ diff --git a/tests/baselines/reference/commentsMultiModuleSingleFile.symbols b/tests/baselines/reference/commentsMultiModuleSingleFile.symbols index 678d9aaf8305c..a6af9521474f2 100644 --- a/tests/baselines/reference/commentsMultiModuleSingleFile.symbols +++ b/tests/baselines/reference/commentsMultiModuleSingleFile.symbols @@ -1,41 +1,40 @@ === tests/cases/compiler/commentsMultiModuleSingleFile.ts === - /** this is multi declare module*/ module multiM { ->multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 10, 1)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 9, 1)) /** class b*/ export class b { ->b : Symbol(b, Decl(commentsMultiModuleSingleFile.ts, 2, 15)) +>b : Symbol(b, Decl(commentsMultiModuleSingleFile.ts, 1, 15)) } // class d export class d { ->d : Symbol(d, Decl(commentsMultiModuleSingleFile.ts, 5, 5)) +>d : Symbol(d, Decl(commentsMultiModuleSingleFile.ts, 4, 5)) } } /// this is multi module 2 module multiM { ->multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 10, 1)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 9, 1)) /** class c comment*/ export class c { ->c : Symbol(c, Decl(commentsMultiModuleSingleFile.ts, 13, 15)) +>c : Symbol(c, Decl(commentsMultiModuleSingleFile.ts, 12, 15)) } /// class e export class e { ->e : Symbol(e, Decl(commentsMultiModuleSingleFile.ts, 16, 5)) +>e : Symbol(e, Decl(commentsMultiModuleSingleFile.ts, 15, 5)) } } new multiM.b(); ->multiM.b : Symbol(multiM.b, Decl(commentsMultiModuleSingleFile.ts, 2, 15)) ->multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 10, 1)) ->b : Symbol(multiM.b, Decl(commentsMultiModuleSingleFile.ts, 2, 15)) +>multiM.b : Symbol(multiM.b, Decl(commentsMultiModuleSingleFile.ts, 1, 15)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 9, 1)) +>b : Symbol(multiM.b, Decl(commentsMultiModuleSingleFile.ts, 1, 15)) new multiM.c(); ->multiM.c : Symbol(multiM.c, Decl(commentsMultiModuleSingleFile.ts, 13, 15)) ->multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 10, 1)) ->c : Symbol(multiM.c, Decl(commentsMultiModuleSingleFile.ts, 13, 15)) +>multiM.c : Symbol(multiM.c, Decl(commentsMultiModuleSingleFile.ts, 12, 15)) +>multiM : Symbol(multiM, Decl(commentsMultiModuleSingleFile.ts, 0, 0), Decl(commentsMultiModuleSingleFile.ts, 9, 1)) +>c : Symbol(multiM.c, Decl(commentsMultiModuleSingleFile.ts, 12, 15)) diff --git a/tests/baselines/reference/commentsMultiModuleSingleFile.types b/tests/baselines/reference/commentsMultiModuleSingleFile.types index 29c18639c21f9..213119c91a550 100644 --- a/tests/baselines/reference/commentsMultiModuleSingleFile.types +++ b/tests/baselines/reference/commentsMultiModuleSingleFile.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsMultiModuleSingleFile.ts === - /** this is multi declare module*/ module multiM { >multiM : typeof multiM diff --git a/tests/baselines/reference/commentsOnObjectLiteral3.js b/tests/baselines/reference/commentsOnObjectLiteral3.js index 49f2a6ffbf951..e6c08f2a3181f 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral3.js +++ b/tests/baselines/reference/commentsOnObjectLiteral3.js @@ -1,5 +1,4 @@ //// [commentsOnObjectLiteral3.ts] - var v = { //property prop: 1 /* multiple trailing comments */ /*trailing comments*/, diff --git a/tests/baselines/reference/commentsOnObjectLiteral3.symbols b/tests/baselines/reference/commentsOnObjectLiteral3.symbols index 3d58fe2d6d7eb..5805180d74d63 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral3.symbols +++ b/tests/baselines/reference/commentsOnObjectLiteral3.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/commentsOnObjectLiteral3.ts === - var v = { ->v : Symbol(v, Decl(commentsOnObjectLiteral3.ts, 1, 3)) +>v : Symbol(v, Decl(commentsOnObjectLiteral3.ts, 0, 3)) //property prop: 1 /* multiple trailing comments */ /*trailing comments*/, ->prop : Symbol(prop, Decl(commentsOnObjectLiteral3.ts, 1, 9)) +>prop : Symbol(prop, Decl(commentsOnObjectLiteral3.ts, 0, 9)) //property func: function () { ->func : Symbol(func, Decl(commentsOnObjectLiteral3.ts, 3, 64)) +>func : Symbol(func, Decl(commentsOnObjectLiteral3.ts, 2, 64)) }, //PropertyName + CallSignature func1() { }, ->func1 : Symbol(func1, Decl(commentsOnObjectLiteral3.ts, 6, 3)) +>func1 : Symbol(func1, Decl(commentsOnObjectLiteral3.ts, 5, 3)) //getter get a() { ->a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 8, 13), Decl(commentsOnObjectLiteral3.ts, 12, 18)) +>a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 7, 13), Decl(commentsOnObjectLiteral3.ts, 11, 18)) return this.prop; } /*trailing 1*/, //setter set a(value) { ->a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 8, 13), Decl(commentsOnObjectLiteral3.ts, 12, 18)) ->value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 14, 7)) +>a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 7, 13), Decl(commentsOnObjectLiteral3.ts, 11, 18)) +>value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 13, 7)) this.prop = value; ->value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 14, 7)) +>value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 13, 7)) } // trailing 2 }; diff --git a/tests/baselines/reference/commentsOnObjectLiteral3.types b/tests/baselines/reference/commentsOnObjectLiteral3.types index 4053e7e3f8938..3c264d4502b5d 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral3.types +++ b/tests/baselines/reference/commentsOnObjectLiteral3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsOnObjectLiteral3.ts === - var v = { >v : { prop: number; func: () => void; func1(): void; a: any; } >{ //property prop: 1 /* multiple trailing comments */ /*trailing comments*/, //property func: function () { }, //PropertyName + CallSignature func1() { }, //getter get a() { return this.prop; } /*trailing 1*/, //setter set a(value) { this.prop = value; } // trailing 2} : { prop: number; func: () => void; func1(): void; a: any; } diff --git a/tests/baselines/reference/commentsOnObjectLiteral4.js b/tests/baselines/reference/commentsOnObjectLiteral4.js index 23e238b8307dc..749201c2f7578 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral4.js +++ b/tests/baselines/reference/commentsOnObjectLiteral4.js @@ -1,5 +1,4 @@ //// [commentsOnObjectLiteral4.ts] - var v = { /** * @type {number} diff --git a/tests/baselines/reference/commentsOnObjectLiteral4.symbols b/tests/baselines/reference/commentsOnObjectLiteral4.symbols index 568d633212625..eb0a8a3e3f017 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral4.symbols +++ b/tests/baselines/reference/commentsOnObjectLiteral4.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/commentsOnObjectLiteral4.ts === - var v = { ->v : Symbol(v, Decl(commentsOnObjectLiteral4.ts, 1, 3)) +>v : Symbol(v, Decl(commentsOnObjectLiteral4.ts, 0, 3)) /** * @type {number} */ get bar(): number { ->bar : Symbol(bar, Decl(commentsOnObjectLiteral4.ts, 1, 9)) +>bar : Symbol(bar, Decl(commentsOnObjectLiteral4.ts, 0, 9)) return 12; } diff --git a/tests/baselines/reference/commentsOnObjectLiteral4.types b/tests/baselines/reference/commentsOnObjectLiteral4.types index 097d43cdd6d83..aa0293edc6cbb 100644 --- a/tests/baselines/reference/commentsOnObjectLiteral4.types +++ b/tests/baselines/reference/commentsOnObjectLiteral4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsOnObjectLiteral4.ts === - var v = { >v : { readonly bar: number; } >{ /** * @type {number} */ get bar(): number { return 12; }} : { readonly bar: number; } diff --git a/tests/baselines/reference/commentsOnRequireStatement.js b/tests/baselines/reference/commentsOnRequireStatement.js index eee05c8049395..2a39206ecf3c0 100644 --- a/tests/baselines/reference/commentsOnRequireStatement.js +++ b/tests/baselines/reference/commentsOnRequireStatement.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commentsOnRequireStatement.ts] //// //// [0.ts] - export var subject = 10; //// [1.ts] diff --git a/tests/baselines/reference/commentsOnRequireStatement.symbols b/tests/baselines/reference/commentsOnRequireStatement.symbols index 2e491b33234df..ec9c468462016 100644 --- a/tests/baselines/reference/commentsOnRequireStatement.symbols +++ b/tests/baselines/reference/commentsOnRequireStatement.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/0.ts === - export var subject = 10; ->subject : Symbol(subject, Decl(0.ts, 1, 10)) +>subject : Symbol(subject, Decl(0.ts, 0, 10)) === tests/cases/compiler/1.ts === export var subject1 = 10; diff --git a/tests/baselines/reference/commentsOnRequireStatement.types b/tests/baselines/reference/commentsOnRequireStatement.types index cd146c731f721..bee717b3ddabc 100644 --- a/tests/baselines/reference/commentsOnRequireStatement.types +++ b/tests/baselines/reference/commentsOnRequireStatement.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - export var subject = 10; >subject : number >10 : 10 diff --git a/tests/baselines/reference/commentsOnStaticMembers.js b/tests/baselines/reference/commentsOnStaticMembers.js index 851f9025be350..94df40898805e 100644 --- a/tests/baselines/reference/commentsOnStaticMembers.js +++ b/tests/baselines/reference/commentsOnStaticMembers.js @@ -1,5 +1,4 @@ //// [commentsOnStaticMembers.ts] - class test { /** * p1 comment appears in output diff --git a/tests/baselines/reference/commentsOnStaticMembers.symbols b/tests/baselines/reference/commentsOnStaticMembers.symbols index 4e59ba7bca97c..7986db58cdaa2 100644 --- a/tests/baselines/reference/commentsOnStaticMembers.symbols +++ b/tests/baselines/reference/commentsOnStaticMembers.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsOnStaticMembers.ts === - class test { >test : Symbol(test, Decl(commentsOnStaticMembers.ts, 0, 0)) @@ -7,23 +6,23 @@ class test { * p1 comment appears in output */ public static p1: string = ""; ->p1 : Symbol(test.p1, Decl(commentsOnStaticMembers.ts, 1, 12)) +>p1 : Symbol(test.p1, Decl(commentsOnStaticMembers.ts, 0, 12)) /** * p2 comment does not appear in output */ public static p2: string; ->p2 : Symbol(test.p2, Decl(commentsOnStaticMembers.ts, 5, 34)) +>p2 : Symbol(test.p2, Decl(commentsOnStaticMembers.ts, 4, 34)) /** * p3 comment appears in output */ private static p3: string = ""; ->p3 : Symbol(test.p3, Decl(commentsOnStaticMembers.ts, 9, 29)) +>p3 : Symbol(test.p3, Decl(commentsOnStaticMembers.ts, 8, 29)) /** * p4 comment does not appear in output */ private static p4: string; ->p4 : Symbol(test.p4, Decl(commentsOnStaticMembers.ts, 14, 35)) +>p4 : Symbol(test.p4, Decl(commentsOnStaticMembers.ts, 13, 35)) } diff --git a/tests/baselines/reference/commentsOnStaticMembers.types b/tests/baselines/reference/commentsOnStaticMembers.types index b4fae1094b68e..c8b3771f3cd37 100644 --- a/tests/baselines/reference/commentsOnStaticMembers.types +++ b/tests/baselines/reference/commentsOnStaticMembers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsOnStaticMembers.ts === - class test { >test : test diff --git a/tests/baselines/reference/commentsVarDecl.js b/tests/baselines/reference/commentsVarDecl.js index 5ff2a3c1c6a85..001b3b5ed1f6f 100644 --- a/tests/baselines/reference/commentsVarDecl.js +++ b/tests/baselines/reference/commentsVarDecl.js @@ -1,5 +1,4 @@ //// [commentsVarDecl.ts] - /** Variable comments*/ var myVariable = 10; // This trailing Comment1 diff --git a/tests/baselines/reference/commentsVarDecl.symbols b/tests/baselines/reference/commentsVarDecl.symbols index d2ec3d4edcdfd..54a1462e28f9a 100644 --- a/tests/baselines/reference/commentsVarDecl.symbols +++ b/tests/baselines/reference/commentsVarDecl.symbols @@ -1,71 +1,70 @@ === tests/cases/compiler/commentsVarDecl.ts === - /** Variable comments*/ var myVariable = 10; // This trailing Comment1 ->myVariable : Symbol(myVariable, Decl(commentsVarDecl.ts, 2, 3)) +>myVariable : Symbol(myVariable, Decl(commentsVarDecl.ts, 1, 3)) /** This is another variable comment*/ var anotherVariable = 30; ->anotherVariable : Symbol(anotherVariable, Decl(commentsVarDecl.ts, 5, 3)) +>anotherVariable : Symbol(anotherVariable, Decl(commentsVarDecl.ts, 4, 3)) // shouldn't appear var aVar = ""; ->aVar : Symbol(aVar, Decl(commentsVarDecl.ts, 8, 3)) +>aVar : Symbol(aVar, Decl(commentsVarDecl.ts, 7, 3)) /** this is multiline comment * All these variables are of number type */ var anotherAnotherVariable = 70; /* these are multiple trailing comments */ /* multiple trailing comments */ ->anotherAnotherVariable : Symbol(anotherAnotherVariable, Decl(commentsVarDecl.ts, 12, 3)) +>anotherAnotherVariable : Symbol(anotherAnotherVariable, Decl(commentsVarDecl.ts, 11, 3)) /** Triple slash multiline comment*/ /** another line in the comment*/ /** comment line 2*/ var x = 70; /* multiline trailing comment ->x : Symbol(x, Decl(commentsVarDecl.ts, 17, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 16, 3)) this is multiline trailing comment */ /** Triple slash comment on the assignement shouldnt be in .d.ts file*/ x = myVariable; ->x : Symbol(x, Decl(commentsVarDecl.ts, 17, 3)) ->myVariable : Symbol(myVariable, Decl(commentsVarDecl.ts, 2, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 16, 3)) +>myVariable : Symbol(myVariable, Decl(commentsVarDecl.ts, 1, 3)) /** triple slash comment1*/ /** jsdocstyle comment - only this comment should be in .d.ts file*/ var n = 30; ->n : Symbol(n, Decl(commentsVarDecl.ts, 24, 3)) +>n : Symbol(n, Decl(commentsVarDecl.ts, 23, 3)) /** var deckaration with comment on type as well*/ var y = /** value comment */ 20; ->y : Symbol(y, Decl(commentsVarDecl.ts, 27, 3)) +>y : Symbol(y, Decl(commentsVarDecl.ts, 26, 3)) /// var deckaration with comment on type as well var yy = ->yy : Symbol(yy, Decl(commentsVarDecl.ts, 30, 3)) +>yy : Symbol(yy, Decl(commentsVarDecl.ts, 29, 3)) /// value comment 20; /** comment2 */ var z = /** lambda comment */ (x: number, y: number) => x + y; ->z : Symbol(z, Decl(commentsVarDecl.ts, 35, 3)) ->x : Symbol(x, Decl(commentsVarDecl.ts, 35, 31)) ->y : Symbol(y, Decl(commentsVarDecl.ts, 35, 41)) ->x : Symbol(x, Decl(commentsVarDecl.ts, 35, 31)) ->y : Symbol(y, Decl(commentsVarDecl.ts, 35, 41)) +>z : Symbol(z, Decl(commentsVarDecl.ts, 34, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 34, 31)) +>y : Symbol(y, Decl(commentsVarDecl.ts, 34, 41)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 34, 31)) +>y : Symbol(y, Decl(commentsVarDecl.ts, 34, 41)) var z2: /** type comment*/ (x: number) => string; ->z2 : Symbol(z2, Decl(commentsVarDecl.ts, 37, 3)) ->x : Symbol(x, Decl(commentsVarDecl.ts, 37, 28)) +>z2 : Symbol(z2, Decl(commentsVarDecl.ts, 36, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 36, 28)) var x2 = z2; ->x2 : Symbol(x2, Decl(commentsVarDecl.ts, 39, 3)) ->z2 : Symbol(z2, Decl(commentsVarDecl.ts, 37, 3)) +>x2 : Symbol(x2, Decl(commentsVarDecl.ts, 38, 3)) +>z2 : Symbol(z2, Decl(commentsVarDecl.ts, 36, 3)) var n4: (x: number) => string; ->n4 : Symbol(n4, Decl(commentsVarDecl.ts, 41, 3)) ->x : Symbol(x, Decl(commentsVarDecl.ts, 41, 9)) +>n4 : Symbol(n4, Decl(commentsVarDecl.ts, 40, 3)) +>x : Symbol(x, Decl(commentsVarDecl.ts, 40, 9)) n4 = z2; ->n4 : Symbol(n4, Decl(commentsVarDecl.ts, 41, 3)) ->z2 : Symbol(z2, Decl(commentsVarDecl.ts, 37, 3)) +>n4 : Symbol(n4, Decl(commentsVarDecl.ts, 40, 3)) +>z2 : Symbol(z2, Decl(commentsVarDecl.ts, 36, 3)) diff --git a/tests/baselines/reference/commentsVarDecl.types b/tests/baselines/reference/commentsVarDecl.types index 1127f5ed3f4b0..a81c329f0027b 100644 --- a/tests/baselines/reference/commentsVarDecl.types +++ b/tests/baselines/reference/commentsVarDecl.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsVarDecl.ts === - /** Variable comments*/ var myVariable = 10; // This trailing Comment1 >myVariable : number diff --git a/tests/baselines/reference/commentsVariableStatement1.js b/tests/baselines/reference/commentsVariableStatement1.js index bc60253e24c3c..1e9579b070646 100644 --- a/tests/baselines/reference/commentsVariableStatement1.js +++ b/tests/baselines/reference/commentsVariableStatement1.js @@ -1,5 +1,4 @@ //// [commentsVariableStatement1.ts] - /** Comment */ var v = 1; diff --git a/tests/baselines/reference/commentsVariableStatement1.symbols b/tests/baselines/reference/commentsVariableStatement1.symbols index 54f382da7937b..aebf32a21bbec 100644 --- a/tests/baselines/reference/commentsVariableStatement1.symbols +++ b/tests/baselines/reference/commentsVariableStatement1.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/commentsVariableStatement1.ts === - /** Comment */ var v = 1; ->v : Symbol(v, Decl(commentsVariableStatement1.ts, 2, 3)) +>v : Symbol(v, Decl(commentsVariableStatement1.ts, 1, 3)) diff --git a/tests/baselines/reference/commentsVariableStatement1.types b/tests/baselines/reference/commentsVariableStatement1.types index 1684f25c570b5..540edc2b2a39a 100644 --- a/tests/baselines/reference/commentsVariableStatement1.types +++ b/tests/baselines/reference/commentsVariableStatement1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsVariableStatement1.ts === - /** Comment */ var v = 1; >v : number diff --git a/tests/baselines/reference/commentsdoNotEmitComments.js b/tests/baselines/reference/commentsdoNotEmitComments.js index b77f51348f0a7..d4d57a7c35f84 100644 --- a/tests/baselines/reference/commentsdoNotEmitComments.js +++ b/tests/baselines/reference/commentsdoNotEmitComments.js @@ -1,5 +1,4 @@ //// [commentsdoNotEmitComments.ts] - /** Variable comments*/ var myVariable = 10; diff --git a/tests/baselines/reference/commentsdoNotEmitComments.symbols b/tests/baselines/reference/commentsdoNotEmitComments.symbols index 01555496dce8e..89324cf1670ab 100644 --- a/tests/baselines/reference/commentsdoNotEmitComments.symbols +++ b/tests/baselines/reference/commentsdoNotEmitComments.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/commentsdoNotEmitComments.ts === - /** Variable comments*/ var myVariable = 10; ->myVariable : Symbol(myVariable, Decl(commentsdoNotEmitComments.ts, 2, 3)) +>myVariable : Symbol(myVariable, Decl(commentsdoNotEmitComments.ts, 1, 3)) /** function comments*/ function foo(/** parameter comment*/p: number) { ->foo : Symbol(foo, Decl(commentsdoNotEmitComments.ts, 2, 20)) ->p : Symbol(p, Decl(commentsdoNotEmitComments.ts, 5, 13)) +>foo : Symbol(foo, Decl(commentsdoNotEmitComments.ts, 1, 20)) +>p : Symbol(p, Decl(commentsdoNotEmitComments.ts, 4, 13)) } /** variable with function type comment*/ var fooVar: () => void; ->fooVar : Symbol(fooVar, Decl(commentsdoNotEmitComments.ts, 9, 3)) +>fooVar : Symbol(fooVar, Decl(commentsdoNotEmitComments.ts, 8, 3)) foo(50); ->foo : Symbol(foo, Decl(commentsdoNotEmitComments.ts, 2, 20)) +>foo : Symbol(foo, Decl(commentsdoNotEmitComments.ts, 1, 20)) fooVar(); ->fooVar : Symbol(fooVar, Decl(commentsdoNotEmitComments.ts, 9, 3)) +>fooVar : Symbol(fooVar, Decl(commentsdoNotEmitComments.ts, 8, 3)) /**class comment*/ class c { ->c : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) +>c : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) /** constructor comment*/ constructor() { @@ -30,132 +29,132 @@ class c { /** property comment */ public b = 10; ->b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) +>b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) /** function comment */ public myFoo() { ->myFoo : Symbol(c.myFoo, Decl(commentsdoNotEmitComments.ts, 20, 18)) +>myFoo : Symbol(c.myFoo, Decl(commentsdoNotEmitComments.ts, 19, 18)) return this.b; ->this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) +>this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) } /** getter comment*/ public get prop1() { ->prop1 : Symbol(c.prop1, Decl(commentsdoNotEmitComments.ts, 25, 5), Decl(commentsdoNotEmitComments.ts, 30, 5)) +>prop1 : Symbol(c.prop1, Decl(commentsdoNotEmitComments.ts, 24, 5), Decl(commentsdoNotEmitComments.ts, 29, 5)) return this.b; ->this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) +>this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) } /** setter comment*/ public set prop1(val: number) { ->prop1 : Symbol(c.prop1, Decl(commentsdoNotEmitComments.ts, 25, 5), Decl(commentsdoNotEmitComments.ts, 30, 5)) ->val : Symbol(val, Decl(commentsdoNotEmitComments.ts, 33, 21)) +>prop1 : Symbol(c.prop1, Decl(commentsdoNotEmitComments.ts, 24, 5), Decl(commentsdoNotEmitComments.ts, 29, 5)) +>val : Symbol(val, Decl(commentsdoNotEmitComments.ts, 32, 21)) this.b = val; ->this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 17, 5)) ->val : Symbol(val, Decl(commentsdoNotEmitComments.ts, 33, 21)) +>this.b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsdoNotEmitComments.ts, 16, 5)) +>val : Symbol(val, Decl(commentsdoNotEmitComments.ts, 32, 21)) } /** overload signature1*/ public foo1(a: number): string; ->foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 35, 5), Decl(commentsdoNotEmitComments.ts, 38, 35), Decl(commentsdoNotEmitComments.ts, 40, 35)) ->a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 38, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 34, 5), Decl(commentsdoNotEmitComments.ts, 37, 35), Decl(commentsdoNotEmitComments.ts, 39, 35)) +>a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 37, 16)) /** Overload signature 2*/ public foo1(b: string): string; ->foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 35, 5), Decl(commentsdoNotEmitComments.ts, 38, 35), Decl(commentsdoNotEmitComments.ts, 40, 35)) ->b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 40, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 34, 5), Decl(commentsdoNotEmitComments.ts, 37, 35), Decl(commentsdoNotEmitComments.ts, 39, 35)) +>b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 39, 16)) /** overload implementation signature*/ public foo1(aOrb) { ->foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 35, 5), Decl(commentsdoNotEmitComments.ts, 38, 35), Decl(commentsdoNotEmitComments.ts, 40, 35)) ->aOrb : Symbol(aOrb, Decl(commentsdoNotEmitComments.ts, 42, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsdoNotEmitComments.ts, 34, 5), Decl(commentsdoNotEmitComments.ts, 37, 35), Decl(commentsdoNotEmitComments.ts, 39, 35)) +>aOrb : Symbol(aOrb, Decl(commentsdoNotEmitComments.ts, 41, 16)) return aOrb.toString(); ->aOrb : Symbol(aOrb, Decl(commentsdoNotEmitComments.ts, 42, 16)) +>aOrb : Symbol(aOrb, Decl(commentsdoNotEmitComments.ts, 41, 16)) } } /**instance comment*/ var i = new c(); ->i : Symbol(i, Decl(commentsdoNotEmitComments.ts, 48, 3)) ->c : Symbol(c, Decl(commentsdoNotEmitComments.ts, 11, 9)) +>i : Symbol(i, Decl(commentsdoNotEmitComments.ts, 47, 3)) +>c : Symbol(c, Decl(commentsdoNotEmitComments.ts, 10, 9)) /** interface comments*/ interface i1 { ->i1 : Symbol(i1, Decl(commentsdoNotEmitComments.ts, 48, 16)) +>i1 : Symbol(i1, Decl(commentsdoNotEmitComments.ts, 47, 16)) /** caller comments*/ (a: number): number; ->a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 53, 5)) +>a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 52, 5)) /** new comments*/ new (b: string); ->b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 56, 9)) +>b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 55, 9)) /**indexer property*/ [a: number]: string; ->a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 59, 5)) +>a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 58, 5)) /** function property;*/ myFoo(/*param prop*/a: number): string; ->myFoo : Symbol(i1.myFoo, Decl(commentsdoNotEmitComments.ts, 59, 24)) ->a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 62, 10)) +>myFoo : Symbol(i1.myFoo, Decl(commentsdoNotEmitComments.ts, 58, 24)) +>a : Symbol(a, Decl(commentsdoNotEmitComments.ts, 61, 10)) /** prop*/ prop: string; ->prop : Symbol(i1.prop, Decl(commentsdoNotEmitComments.ts, 62, 43)) +>prop : Symbol(i1.prop, Decl(commentsdoNotEmitComments.ts, 61, 43)) } /**interface instance comments*/ var i1_i: i1; ->i1_i : Symbol(i1_i, Decl(commentsdoNotEmitComments.ts, 69, 3)) ->i1 : Symbol(i1, Decl(commentsdoNotEmitComments.ts, 48, 16)) +>i1_i : Symbol(i1_i, Decl(commentsdoNotEmitComments.ts, 68, 3)) +>i1 : Symbol(i1, Decl(commentsdoNotEmitComments.ts, 47, 16)) /** this is module comment*/ module m1 { ->m1 : Symbol(m1, Decl(commentsdoNotEmitComments.ts, 69, 13)) +>m1 : Symbol(m1, Decl(commentsdoNotEmitComments.ts, 68, 13)) /** class b */ export class b { ->b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 72, 11)) +>b : Symbol(b, Decl(commentsdoNotEmitComments.ts, 71, 11)) constructor(public x: number) { ->x : Symbol(b.x, Decl(commentsdoNotEmitComments.ts, 75, 20)) +>x : Symbol(b.x, Decl(commentsdoNotEmitComments.ts, 74, 20)) } } /// module m2 export module m2 { ->m2 : Symbol(m2, Decl(commentsdoNotEmitComments.ts, 78, 5)) +>m2 : Symbol(m2, Decl(commentsdoNotEmitComments.ts, 77, 5)) } } /// this is x declare var x; ->x : Symbol(x, Decl(commentsdoNotEmitComments.ts, 86, 11)) +>x : Symbol(x, Decl(commentsdoNotEmitComments.ts, 85, 11)) /** const enum member value comment (generated by TS) */ const enum color { red, green, blue } ->color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 86, 14)) ->red : Symbol(color.red, Decl(commentsdoNotEmitComments.ts, 90, 18)) ->green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 90, 23)) ->blue : Symbol(color.blue, Decl(commentsdoNotEmitComments.ts, 90, 30)) +>color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 85, 14)) +>red : Symbol(color.red, Decl(commentsdoNotEmitComments.ts, 89, 18)) +>green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 89, 23)) +>blue : Symbol(color.blue, Decl(commentsdoNotEmitComments.ts, 89, 30)) var shade: color = color.green; ->shade : Symbol(shade, Decl(commentsdoNotEmitComments.ts, 91, 3)) ->color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 86, 14)) ->color.green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 90, 23)) ->color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 86, 14)) ->green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 90, 23)) +>shade : Symbol(shade, Decl(commentsdoNotEmitComments.ts, 90, 3)) +>color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 85, 14)) +>color.green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 89, 23)) +>color : Symbol(color, Decl(commentsdoNotEmitComments.ts, 85, 14)) +>green : Symbol(color.green, Decl(commentsdoNotEmitComments.ts, 89, 23)) diff --git a/tests/baselines/reference/commentsdoNotEmitComments.types b/tests/baselines/reference/commentsdoNotEmitComments.types index e30555db69a86..1c30eeca50b5b 100644 --- a/tests/baselines/reference/commentsdoNotEmitComments.types +++ b/tests/baselines/reference/commentsdoNotEmitComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsdoNotEmitComments.ts === - /** Variable comments*/ var myVariable = 10; >myVariable : number diff --git a/tests/baselines/reference/commentsemitComments.js b/tests/baselines/reference/commentsemitComments.js index 442f558bcfaaa..6e0497fcf7fac 100644 --- a/tests/baselines/reference/commentsemitComments.js +++ b/tests/baselines/reference/commentsemitComments.js @@ -1,5 +1,4 @@ //// [commentsemitComments.ts] - /** Variable comments*/ var myVariable = 10; diff --git a/tests/baselines/reference/commentsemitComments.symbols b/tests/baselines/reference/commentsemitComments.symbols index eec41dccec66f..08ae7df049411 100644 --- a/tests/baselines/reference/commentsemitComments.symbols +++ b/tests/baselines/reference/commentsemitComments.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/commentsemitComments.ts === - /** Variable comments*/ var myVariable = 10; ->myVariable : Symbol(myVariable, Decl(commentsemitComments.ts, 2, 3)) +>myVariable : Symbol(myVariable, Decl(commentsemitComments.ts, 1, 3)) /** function comments*/ function foo(/** parameter comment*/p: number) { ->foo : Symbol(foo, Decl(commentsemitComments.ts, 2, 20)) ->p : Symbol(p, Decl(commentsemitComments.ts, 5, 13)) +>foo : Symbol(foo, Decl(commentsemitComments.ts, 1, 20)) +>p : Symbol(p, Decl(commentsemitComments.ts, 4, 13)) } /** variable with function type comment*/ var fooVar: () => void; ->fooVar : Symbol(fooVar, Decl(commentsemitComments.ts, 9, 3)) +>fooVar : Symbol(fooVar, Decl(commentsemitComments.ts, 8, 3)) foo(50); ->foo : Symbol(foo, Decl(commentsemitComments.ts, 2, 20)) +>foo : Symbol(foo, Decl(commentsemitComments.ts, 1, 20)) fooVar(); ->fooVar : Symbol(fooVar, Decl(commentsemitComments.ts, 9, 3)) +>fooVar : Symbol(fooVar, Decl(commentsemitComments.ts, 8, 3)) /**class comment*/ class c { ->c : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) +>c : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) /** constructor comment*/ constructor() { @@ -30,117 +29,117 @@ class c { /** property comment */ public b = 10; ->b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) +>b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) /** function comment */ public myFoo() { ->myFoo : Symbol(c.myFoo, Decl(commentsemitComments.ts, 20, 18)) +>myFoo : Symbol(c.myFoo, Decl(commentsemitComments.ts, 19, 18)) return this.b; ->this.b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) +>this.b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) } /** getter comment*/ public get prop1() { ->prop1 : Symbol(c.prop1, Decl(commentsemitComments.ts, 25, 5), Decl(commentsemitComments.ts, 30, 5)) +>prop1 : Symbol(c.prop1, Decl(commentsemitComments.ts, 24, 5), Decl(commentsemitComments.ts, 29, 5)) return this.b; ->this.b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) +>this.b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) } /** setter comment*/ public set prop1(val: number) { ->prop1 : Symbol(c.prop1, Decl(commentsemitComments.ts, 25, 5), Decl(commentsemitComments.ts, 30, 5)) ->val : Symbol(val, Decl(commentsemitComments.ts, 33, 21)) +>prop1 : Symbol(c.prop1, Decl(commentsemitComments.ts, 24, 5), Decl(commentsemitComments.ts, 29, 5)) +>val : Symbol(val, Decl(commentsemitComments.ts, 32, 21)) this.b = val; ->this.b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) ->this : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) ->b : Symbol(c.b, Decl(commentsemitComments.ts, 17, 5)) ->val : Symbol(val, Decl(commentsemitComments.ts, 33, 21)) +>this.b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) +>this : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) +>b : Symbol(c.b, Decl(commentsemitComments.ts, 16, 5)) +>val : Symbol(val, Decl(commentsemitComments.ts, 32, 21)) } /** overload signature1*/ public foo1(a: number): string; ->foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 35, 5), Decl(commentsemitComments.ts, 38, 35), Decl(commentsemitComments.ts, 40, 35)) ->a : Symbol(a, Decl(commentsemitComments.ts, 38, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 34, 5), Decl(commentsemitComments.ts, 37, 35), Decl(commentsemitComments.ts, 39, 35)) +>a : Symbol(a, Decl(commentsemitComments.ts, 37, 16)) /** Overload signature 2*/ public foo1(b: string): string; ->foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 35, 5), Decl(commentsemitComments.ts, 38, 35), Decl(commentsemitComments.ts, 40, 35)) ->b : Symbol(b, Decl(commentsemitComments.ts, 40, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 34, 5), Decl(commentsemitComments.ts, 37, 35), Decl(commentsemitComments.ts, 39, 35)) +>b : Symbol(b, Decl(commentsemitComments.ts, 39, 16)) /** overload implementation signature*/ public foo1(aOrb) { ->foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 35, 5), Decl(commentsemitComments.ts, 38, 35), Decl(commentsemitComments.ts, 40, 35)) ->aOrb : Symbol(aOrb, Decl(commentsemitComments.ts, 42, 16)) +>foo1 : Symbol(c.foo1, Decl(commentsemitComments.ts, 34, 5), Decl(commentsemitComments.ts, 37, 35), Decl(commentsemitComments.ts, 39, 35)) +>aOrb : Symbol(aOrb, Decl(commentsemitComments.ts, 41, 16)) return aOrb.toString(); ->aOrb : Symbol(aOrb, Decl(commentsemitComments.ts, 42, 16)) +>aOrb : Symbol(aOrb, Decl(commentsemitComments.ts, 41, 16)) } } /**instance comment*/ var i = new c(); ->i : Symbol(i, Decl(commentsemitComments.ts, 48, 3)) ->c : Symbol(c, Decl(commentsemitComments.ts, 11, 9)) +>i : Symbol(i, Decl(commentsemitComments.ts, 47, 3)) +>c : Symbol(c, Decl(commentsemitComments.ts, 10, 9)) /** interface comments*/ interface i1 { ->i1 : Symbol(i1, Decl(commentsemitComments.ts, 48, 16)) +>i1 : Symbol(i1, Decl(commentsemitComments.ts, 47, 16)) /** caller comments*/ (a: number): number; ->a : Symbol(a, Decl(commentsemitComments.ts, 53, 5)) +>a : Symbol(a, Decl(commentsemitComments.ts, 52, 5)) /** new comments*/ new (b: string); ->b : Symbol(b, Decl(commentsemitComments.ts, 56, 9)) +>b : Symbol(b, Decl(commentsemitComments.ts, 55, 9)) /**indexer property*/ [a: number]: string; ->a : Symbol(a, Decl(commentsemitComments.ts, 59, 5)) +>a : Symbol(a, Decl(commentsemitComments.ts, 58, 5)) /** function property;*/ myFoo(/*param prop*/a: number): string; ->myFoo : Symbol(i1.myFoo, Decl(commentsemitComments.ts, 59, 24)) ->a : Symbol(a, Decl(commentsemitComments.ts, 62, 10)) +>myFoo : Symbol(i1.myFoo, Decl(commentsemitComments.ts, 58, 24)) +>a : Symbol(a, Decl(commentsemitComments.ts, 61, 10)) /** prop*/ prop: string; ->prop : Symbol(i1.prop, Decl(commentsemitComments.ts, 62, 43)) +>prop : Symbol(i1.prop, Decl(commentsemitComments.ts, 61, 43)) } /**interface instance comments*/ var i1_i: i1; ->i1_i : Symbol(i1_i, Decl(commentsemitComments.ts, 69, 3)) ->i1 : Symbol(i1, Decl(commentsemitComments.ts, 48, 16)) +>i1_i : Symbol(i1_i, Decl(commentsemitComments.ts, 68, 3)) +>i1 : Symbol(i1, Decl(commentsemitComments.ts, 47, 16)) /** this is module comment*/ module m1 { ->m1 : Symbol(m1, Decl(commentsemitComments.ts, 69, 13)) +>m1 : Symbol(m1, Decl(commentsemitComments.ts, 68, 13)) /** class b */ export class b { ->b : Symbol(b, Decl(commentsemitComments.ts, 72, 11)) +>b : Symbol(b, Decl(commentsemitComments.ts, 71, 11)) constructor(public x: number) { ->x : Symbol(b.x, Decl(commentsemitComments.ts, 75, 20)) +>x : Symbol(b.x, Decl(commentsemitComments.ts, 74, 20)) } } /// module m2 export module m2 { ->m2 : Symbol(m2, Decl(commentsemitComments.ts, 78, 5)) +>m2 : Symbol(m2, Decl(commentsemitComments.ts, 77, 5)) } } /// this is x declare var x; ->x : Symbol(x, Decl(commentsemitComments.ts, 86, 11)) +>x : Symbol(x, Decl(commentsemitComments.ts, 85, 11)) diff --git a/tests/baselines/reference/commentsemitComments.types b/tests/baselines/reference/commentsemitComments.types index 03bf0912092d1..6c2429091e2cc 100644 --- a/tests/baselines/reference/commentsemitComments.types +++ b/tests/baselines/reference/commentsemitComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/commentsemitComments.ts === - /** Variable comments*/ var myVariable = 10; >myVariable : number diff --git a/tests/baselines/reference/commonSourceDir5.js b/tests/baselines/reference/commonSourceDir5.js index ef6e97f4d5e76..78517e4e51527 100644 --- a/tests/baselines/reference/commonSourceDir5.js +++ b/tests/baselines/reference/commonSourceDir5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commonSourceDir5.ts] //// //// [bar.ts] - import {z} from "./foo"; export var x = z + z; diff --git a/tests/baselines/reference/commonSourceDir5.symbols b/tests/baselines/reference/commonSourceDir5.symbols index 67494af40fa53..6426ac39de3c4 100644 --- a/tests/baselines/reference/commonSourceDir5.symbols +++ b/tests/baselines/reference/commonSourceDir5.symbols @@ -1,12 +1,11 @@ === A:/bar.ts === - import {z} from "./foo"; ->z : Symbol(z, Decl(bar.ts, 1, 8)) +>z : Symbol(z, Decl(bar.ts, 0, 8)) export var x = z + z; ->x : Symbol(x, Decl(bar.ts, 2, 10)) ->z : Symbol(z, Decl(bar.ts, 1, 8)) ->z : Symbol(z, Decl(bar.ts, 1, 8)) +>x : Symbol(x, Decl(bar.ts, 1, 10)) +>z : Symbol(z, Decl(bar.ts, 0, 8)) +>z : Symbol(z, Decl(bar.ts, 0, 8)) === A:/foo.ts === import {pi} from "B:/baz"; diff --git a/tests/baselines/reference/commonSourceDir5.types b/tests/baselines/reference/commonSourceDir5.types index f1c3e40e983d7..3e2b99f32596a 100644 --- a/tests/baselines/reference/commonSourceDir5.types +++ b/tests/baselines/reference/commonSourceDir5.types @@ -1,5 +1,4 @@ === A:/bar.ts === - import {z} from "./foo"; >z : number diff --git a/tests/baselines/reference/commonjsSafeImport.js b/tests/baselines/reference/commonjsSafeImport.js index e7a251e9cee3c..5eb560f8bb993 100644 --- a/tests/baselines/reference/commonjsSafeImport.js +++ b/tests/baselines/reference/commonjsSafeImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/commonjsSafeImport.ts] //// //// [10_lib.ts] - export function Foo() {} //// [main.ts] diff --git a/tests/baselines/reference/commonjsSafeImport.symbols b/tests/baselines/reference/commonjsSafeImport.symbols index 45e247b46a05a..d08497ca3a522 100644 --- a/tests/baselines/reference/commonjsSafeImport.symbols +++ b/tests/baselines/reference/commonjsSafeImport.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/10_lib.ts === - export function Foo() {} >Foo : Symbol(Foo, Decl(10_lib.ts, 0, 0)) diff --git a/tests/baselines/reference/commonjsSafeImport.types b/tests/baselines/reference/commonjsSafeImport.types index 5a4dded5b1f4b..898b26f62ab95 100644 --- a/tests/baselines/reference/commonjsSafeImport.types +++ b/tests/baselines/reference/commonjsSafeImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/10_lib.ts === - export function Foo() {} >Foo : () => void diff --git a/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.symbols b/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.symbols index 4448defa95eb3..5aba2118e27b8 100644 --- a/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.symbols +++ b/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : Symbol(c, Decl(a.ts, 0, 0)) } diff --git a/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.types b/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.types index 6f5caf9d48b78..66a158067e41c 100644 --- a/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.types +++ b/tests/baselines/reference/compilerOptionsDeclarationAndNoEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : c } diff --git a/tests/baselines/reference/compilerOptionsOutAndNoEmit.symbols b/tests/baselines/reference/compilerOptionsOutAndNoEmit.symbols index 4448defa95eb3..5aba2118e27b8 100644 --- a/tests/baselines/reference/compilerOptionsOutAndNoEmit.symbols +++ b/tests/baselines/reference/compilerOptionsOutAndNoEmit.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : Symbol(c, Decl(a.ts, 0, 0)) } diff --git a/tests/baselines/reference/compilerOptionsOutAndNoEmit.types b/tests/baselines/reference/compilerOptionsOutAndNoEmit.types index 6f5caf9d48b78..66a158067e41c 100644 --- a/tests/baselines/reference/compilerOptionsOutAndNoEmit.types +++ b/tests/baselines/reference/compilerOptionsOutAndNoEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : c } diff --git a/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.symbols b/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.symbols index 4448defa95eb3..5aba2118e27b8 100644 --- a/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.symbols +++ b/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : Symbol(c, Decl(a.ts, 0, 0)) } diff --git a/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.types b/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.types index 6f5caf9d48b78..66a158067e41c 100644 --- a/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.types +++ b/tests/baselines/reference/compilerOptionsOutDirAndNoEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : c } diff --git a/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.symbols b/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.symbols index 4448defa95eb3..5aba2118e27b8 100644 --- a/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.symbols +++ b/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : Symbol(c, Decl(a.ts, 0, 0)) } diff --git a/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.types b/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.types index 6f5caf9d48b78..66a158067e41c 100644 --- a/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.types +++ b/tests/baselines/reference/compilerOptionsOutFileAndNoEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - class c { >c : c } diff --git a/tests/baselines/reference/complexNarrowingWithAny.js b/tests/baselines/reference/complexNarrowingWithAny.js index 4408d64acbfdf..4531cde9f3ed3 100644 --- a/tests/baselines/reference/complexNarrowingWithAny.js +++ b/tests/baselines/reference/complexNarrowingWithAny.js @@ -560,8 +560,8 @@ export function viewFactory_AppComponent0(viewUtils:any,parentInjector:any,decla //// [complexNarrowingWithAny.js] -// Repro from #10869 "use strict"; +// Repro from #10869 exports.__esModule = true; /** * This file is generated by the Angular 2 template compiler. diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt index 8948467c590dd..7b9eb40dee026 100644 --- a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt +++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt @@ -1,83 +1,82 @@ -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(9,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(13,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(17,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(11,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(15,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(21,5): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(22,5): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(23,5): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(25,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(26,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(27,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(30,1): error TS2539: Cannot assign to 'M' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(31,1): error TS2539: Cannot assign to 'M' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(32,1): error TS2539: Cannot assign to 'M' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(33,1): error TS2539: Cannot assign to 'C' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(34,1): error TS2539: Cannot assign to 'C' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(35,1): error TS2539: Cannot assign to 'C' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(37,1): error TS2539: Cannot assign to 'E' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(38,1): error TS2539: Cannot assign to 'E' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(39,1): error TS2539: Cannot assign to 'E' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(40,1): error TS2539: Cannot assign to 'foo' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(41,1): error TS2539: Cannot assign to 'foo' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(42,1): error TS2539: Cannot assign to 'foo' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(44,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(44,1): error TS2531: Object is possibly 'null'. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(45,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(45,1): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(50,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(51,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(56,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(58,9): error TS1128: Declaration or statement expected. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(59,9): error TS1128: Declaration or statement expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(60,9): error TS1128: Declaration or statement expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(64,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(62,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(69,15): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(70,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(71,15): error TS1034: 'super' must be followed by an argument list or member access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(74,15): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(75,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(76,15): error TS1034: 'super' must be followed by an argument list or member access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(79,15): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(80,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(81,15): error TS1034: 'super' must be followed by an argument list or member access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(85,21): error TS1128: Declaration or statement expected. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(86,21): error TS1128: Declaration or statement expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,21): error TS1128: Declaration or statement expected. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,11): error TS1005: ';' expected. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(88,11): error TS1005: ';' expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(89,11): error TS1005: ';' expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(93,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(91,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(95,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(96,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,2): error TS2539: Cannot assign to 'M' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(98,2): error TS2539: Cannot assign to 'M' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,2): error TS2539: Cannot assign to 'M' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,2): error TS2539: Cannot assign to 'C' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(100,2): error TS2539: Cannot assign to 'C' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,2): error TS2539: Cannot assign to 'C' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,2): error TS2539: Cannot assign to 'E' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(102,2): error TS2539: Cannot assign to 'E' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,2): error TS2539: Cannot assign to 'E' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,2): error TS2539: Cannot assign to 'foo' because it is not a variable. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(104,2): error TS2539: Cannot assign to 'foo' because it is not a variable. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,2): error TS2539: Cannot assign to 'foo' because it is not a variable. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,1): error TS2531: Object is possibly 'null'. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(106,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(106,1): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(109,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(110,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(123,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. ==== tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts (76 errors) ==== - // expected error for all the LHS of compound assignments (arithmetic and addition) var value: any; diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.js b/tests/baselines/reference/compoundAssignmentLHSIsValue.js index 064f2157c1ecc..f5a0fc75da5cf 100644 --- a/tests/baselines/reference/compoundAssignmentLHSIsValue.js +++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.js @@ -1,5 +1,4 @@ //// [compoundAssignmentLHSIsValue.ts] - // expected error for all the LHS of compound assignments (arithmetic and addition) var value: any; diff --git a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.js b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.js index e0bd16287ee09..c75890748fc4d 100644 --- a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.js +++ b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.js @@ -1,5 +1,4 @@ //// [computedPropertiesInDestructuring2_ES6.ts] - let foo2 = () => "bar"; let {[foo2()]: bar3} = {}; diff --git a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.symbols b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.symbols index cd7cfda98441a..fdf6c0eeb7ff1 100644 --- a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.symbols +++ b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/computedPropertiesInDestructuring2_ES6.ts === - let foo2 = () => "bar"; ->foo2 : Symbol(foo2, Decl(computedPropertiesInDestructuring2_ES6.ts, 1, 3)) +>foo2 : Symbol(foo2, Decl(computedPropertiesInDestructuring2_ES6.ts, 0, 3)) let {[foo2()]: bar3} = {}; ->foo2 : Symbol(foo2, Decl(computedPropertiesInDestructuring2_ES6.ts, 1, 3)) ->bar3 : Symbol(bar3, Decl(computedPropertiesInDestructuring2_ES6.ts, 2, 5)) +>foo2 : Symbol(foo2, Decl(computedPropertiesInDestructuring2_ES6.ts, 0, 3)) +>bar3 : Symbol(bar3, Decl(computedPropertiesInDestructuring2_ES6.ts, 1, 5)) diff --git a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.types b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.types index 979689438d299..e59addd3a26be 100644 --- a/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.types +++ b/tests/baselines/reference/computedPropertiesInDestructuring2_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/computedPropertiesInDestructuring2_ES6.ts === - let foo2 = () => "bar"; >foo2 : () => string >() => "bar" : () => string diff --git a/tests/baselines/reference/computedPropertyNames49_ES5.errors.txt b/tests/baselines/reference/computedPropertyNames49_ES5.errors.txt index cb4034d3badb4..02721368a0dfd 100644 --- a/tests/baselines/reference/computedPropertyNames49_ES5.errors.txt +++ b/tests/baselines/reference/computedPropertyNames49_ES5.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(4,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(7,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(10,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(14,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(14,9): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(19,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(19,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(19,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(3,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(6,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(9,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(13,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(13,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(18,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(18,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts(18,9): error TS2300: Duplicate identifier 'foo'. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES5.ts (8 errors) ==== - var x = { p1: 10, get [1 + 1]() { diff --git a/tests/baselines/reference/computedPropertyNames49_ES5.js b/tests/baselines/reference/computedPropertyNames49_ES5.js index d4eb26a08a533..d5e250fb0379d 100644 --- a/tests/baselines/reference/computedPropertyNames49_ES5.js +++ b/tests/baselines/reference/computedPropertyNames49_ES5.js @@ -1,5 +1,4 @@ //// [computedPropertyNames49_ES5.ts] - var x = { p1: 10, get [1 + 1]() { diff --git a/tests/baselines/reference/computedPropertyNames49_ES6.errors.txt b/tests/baselines/reference/computedPropertyNames49_ES6.errors.txt index 276f7fb17bed5..094da3258d6b7 100644 --- a/tests/baselines/reference/computedPropertyNames49_ES6.errors.txt +++ b/tests/baselines/reference/computedPropertyNames49_ES6.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(10,9): error TS1049: A 'set' accessor must have exactly one parameter. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(14,9): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(19,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. -tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(19,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(9,9): error TS1049: A 'set' accessor must have exactly one parameter. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(13,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(18,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. +tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts(18,9): error TS2300: Duplicate identifier 'foo'. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames49_ES6.ts (4 errors) ==== - var x = { p1: 10, get [1 + 1]() { diff --git a/tests/baselines/reference/computedPropertyNames49_ES6.js b/tests/baselines/reference/computedPropertyNames49_ES6.js index d1b5fe26e9d3d..d75df44463fea 100644 --- a/tests/baselines/reference/computedPropertyNames49_ES6.js +++ b/tests/baselines/reference/computedPropertyNames49_ES6.js @@ -1,5 +1,4 @@ //// [computedPropertyNames49_ES6.ts] - var x = { p1: 10, get [1 + 1]() { diff --git a/tests/baselines/reference/computedPropertyNames50_ES5.errors.txt b/tests/baselines/reference/computedPropertyNames50_ES5.errors.txt index 63832dbed0cfd..12d3dde29508b 100644 --- a/tests/baselines/reference/computedPropertyNames50_ES5.errors.txt +++ b/tests/baselines/reference/computedPropertyNames50_ES5.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(4,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(4,9): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(9,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(12,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(16,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(19,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(19,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(19,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(3,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(3,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(8,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(11,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(15,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(18,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(18,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts(18,9): error TS2300: Duplicate identifier 'foo'. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES5.ts (8 errors) ==== - var x = { p1: 10, get foo() { diff --git a/tests/baselines/reference/computedPropertyNames50_ES5.js b/tests/baselines/reference/computedPropertyNames50_ES5.js index 0c6f1798c933e..5f1766c993e15 100644 --- a/tests/baselines/reference/computedPropertyNames50_ES5.js +++ b/tests/baselines/reference/computedPropertyNames50_ES5.js @@ -1,5 +1,4 @@ //// [computedPropertyNames50_ES5.ts] - var x = { p1: 10, get foo() { diff --git a/tests/baselines/reference/computedPropertyNames50_ES6.errors.txt b/tests/baselines/reference/computedPropertyNames50_ES6.errors.txt index db61444a6976f..e2cd3f215bfd2 100644 --- a/tests/baselines/reference/computedPropertyNames50_ES6.errors.txt +++ b/tests/baselines/reference/computedPropertyNames50_ES6.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(4,9): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(12,9): error TS1049: A 'set' accessor must have exactly one parameter. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(19,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. -tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(19,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(3,9): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(11,9): error TS1049: A 'set' accessor must have exactly one parameter. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(18,9): error TS1118: An object literal cannot have multiple get/set accessors with the same name. +tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts(18,9): error TS2300: Duplicate identifier 'foo'. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames50_ES6.ts (4 errors) ==== - var x = { p1: 10, get foo() { diff --git a/tests/baselines/reference/computedPropertyNames50_ES6.js b/tests/baselines/reference/computedPropertyNames50_ES6.js index 24b0c8af1f59a..aa4cc9312340d 100644 --- a/tests/baselines/reference/computedPropertyNames50_ES6.js +++ b/tests/baselines/reference/computedPropertyNames50_ES6.js @@ -1,5 +1,4 @@ //// [computedPropertyNames50_ES6.ts] - var x = { p1: 10, get foo() { diff --git a/tests/baselines/reference/concatError.js b/tests/baselines/reference/concatError.js index dee3d8a30e335..6736171970248 100644 --- a/tests/baselines/reference/concatError.js +++ b/tests/baselines/reference/concatError.js @@ -1,5 +1,4 @@ //// [concatError.ts] - var n1: number[]; /* interface Array { diff --git a/tests/baselines/reference/concatError.symbols b/tests/baselines/reference/concatError.symbols index d4f04531fc7e2..2dcc2f3abd867 100644 --- a/tests/baselines/reference/concatError.symbols +++ b/tests/baselines/reference/concatError.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/concatError.ts === - var n1: number[]; ->n1 : Symbol(n1, Decl(concatError.ts, 1, 3)) +>n1 : Symbol(n1, Decl(concatError.ts, 0, 3)) /* interface Array { @@ -10,18 +9,18 @@ interface Array { } */ var fa: number[]; ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) fa = fa.concat([0]); ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) >fa.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) >concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) fa = fa.concat(0); ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) >fa.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->fa : Symbol(fa, Decl(concatError.ts, 8, 3)) +>fa : Symbol(fa, Decl(concatError.ts, 7, 3)) >concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/concatError.types b/tests/baselines/reference/concatError.types index bb9a85a91b4c6..f97018cd3b9d9 100644 --- a/tests/baselines/reference/concatError.types +++ b/tests/baselines/reference/concatError.types @@ -1,5 +1,4 @@ === tests/cases/compiler/concatError.ts === - var n1: number[]; >n1 : number[] diff --git a/tests/baselines/reference/conditionalExpressions2.js b/tests/baselines/reference/conditionalExpressions2.js index 8ac7df12cfa25..6749a2c0ac080 100644 --- a/tests/baselines/reference/conditionalExpressions2.js +++ b/tests/baselines/reference/conditionalExpressions2.js @@ -1,5 +1,4 @@ //// [conditionalExpressions2.ts] - var a = false ? 1 : null; var b = false ? undefined : 0; var c = false ? 1 : 0; diff --git a/tests/baselines/reference/conditionalExpressions2.symbols b/tests/baselines/reference/conditionalExpressions2.symbols index e6edd635b4043..63c8b41747756 100644 --- a/tests/baselines/reference/conditionalExpressions2.symbols +++ b/tests/baselines/reference/conditionalExpressions2.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/conditionalExpressions2.ts === - var a = false ? 1 : null; ->a : Symbol(a, Decl(conditionalExpressions2.ts, 1, 3)) +>a : Symbol(a, Decl(conditionalExpressions2.ts, 0, 3)) var b = false ? undefined : 0; ->b : Symbol(b, Decl(conditionalExpressions2.ts, 2, 3)) +>b : Symbol(b, Decl(conditionalExpressions2.ts, 1, 3)) >undefined : Symbol(undefined) var c = false ? 1 : 0; ->c : Symbol(c, Decl(conditionalExpressions2.ts, 3, 3)) +>c : Symbol(c, Decl(conditionalExpressions2.ts, 2, 3)) var d = false ? false : true; ->d : Symbol(d, Decl(conditionalExpressions2.ts, 4, 3)) +>d : Symbol(d, Decl(conditionalExpressions2.ts, 3, 3)) var e = false ? "foo" : "bar"; ->e : Symbol(e, Decl(conditionalExpressions2.ts, 5, 3)) +>e : Symbol(e, Decl(conditionalExpressions2.ts, 4, 3)) var f = false ? null : undefined; ->f : Symbol(f, Decl(conditionalExpressions2.ts, 6, 3)) +>f : Symbol(f, Decl(conditionalExpressions2.ts, 5, 3)) >undefined : Symbol(undefined) var g = true ? {g:5} : null; ->g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 3)) ->g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 16)) +>g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 3)) +>g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 16)) var h = [{h:5}, null]; ->h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 3)) ->h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 10)) +>h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 3)) +>h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 10)) function i() { if (true) { return { x: 5 }; } else { return null; } } ->i : Symbol(i, Decl(conditionalExpressions2.ts, 8, 22)) ->x : Symbol(x, Decl(conditionalExpressions2.ts, 9, 35)) +>i : Symbol(i, Decl(conditionalExpressions2.ts, 7, 22)) +>x : Symbol(x, Decl(conditionalExpressions2.ts, 8, 35)) diff --git a/tests/baselines/reference/conditionalExpressions2.types b/tests/baselines/reference/conditionalExpressions2.types index c2b2e23e57b1c..325a281738faf 100644 --- a/tests/baselines/reference/conditionalExpressions2.types +++ b/tests/baselines/reference/conditionalExpressions2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/conditionalExpressions2.ts === - var a = false ? 1 : null; >a : number >false ? 1 : null : 1 diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.errors.txt b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.errors.txt index 24af601139fb5..54aa6baf49ccd 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.errors.txt +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(7,9): error TS2481: Cannot initialize outer scoped variable 'x' in the same scope as block scoped declaration 'x'. -tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(15,13): error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. -tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(22,7): error TS2481: Cannot initialize outer scoped variable 'z' in the same scope as block scoped declaration 'z'. +tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(6,9): error TS2481: Cannot initialize outer scoped variable 'x' in the same scope as block scoped declaration 'x'. +tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(14,13): error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. +tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts(21,7): error TS2481: Cannot initialize outer scoped variable 'z' in the same scope as block scoped declaration 'z'. ==== tests/cases/compiler/constDeclarationShadowedByVarDeclaration.ts (3 errors) ==== - // Error as declaration of var would cause a write to the const value var x = 0; { diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.js b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.js index 9fcc9f8f568f2..fff38e729fd4c 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.js +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration.js @@ -1,5 +1,4 @@ //// [constDeclarationShadowedByVarDeclaration.ts] - // Error as declaration of var would cause a write to the const value var x = 0; { diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.js b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.js index 67d3e688075ad..895b4122d666f 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.js +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.js @@ -1,5 +1,4 @@ //// [constDeclarationShadowedByVarDeclaration2.ts] - // No errors, const declaration is not shadowed function outer() { const x = 0; diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.symbols b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.symbols index db53aa8fb9278..cd187a5944744 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.symbols +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/constDeclarationShadowedByVarDeclaration2.ts === - // No errors, const declaration is not shadowed function outer() { >outer : Symbol(outer, Decl(constDeclarationShadowedByVarDeclaration2.ts, 0, 0)) const x = 0; ->x : Symbol(x, Decl(constDeclarationShadowedByVarDeclaration2.ts, 3, 9)) +>x : Symbol(x, Decl(constDeclarationShadowedByVarDeclaration2.ts, 2, 9)) function inner() { ->inner : Symbol(inner, Decl(constDeclarationShadowedByVarDeclaration2.ts, 3, 16)) +>inner : Symbol(inner, Decl(constDeclarationShadowedByVarDeclaration2.ts, 2, 16)) var x = "inner"; ->x : Symbol(x, Decl(constDeclarationShadowedByVarDeclaration2.ts, 5, 11)) +>x : Symbol(x, Decl(constDeclarationShadowedByVarDeclaration2.ts, 4, 11)) } } diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.types b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.types index 23e81800264a2..3e3821372cce0 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.types +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarationShadowedByVarDeclaration2.ts === - // No errors, const declaration is not shadowed function outer() { >outer : () => void diff --git a/tests/baselines/reference/constDeclarations-access.errors.txt b/tests/baselines/reference/constDeclarations-access.errors.txt index 81121b6fe5ceb..c9c730456e237 100644 --- a/tests/baselines/reference/constDeclarations-access.errors.txt +++ b/tests/baselines/reference/constDeclarations-access.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/file2.ts(1,1): error TS2540: Cannot assign to 'x' because i ==== tests/cases/compiler/file1.ts (0 errors) ==== - const x = 0 ==== tests/cases/compiler/file2.ts (1 errors) ==== diff --git a/tests/baselines/reference/constDeclarations-access.js b/tests/baselines/reference/constDeclarations-access.js index ba913f2d5fce9..dd5624bcf4c8a 100644 --- a/tests/baselines/reference/constDeclarations-access.js +++ b/tests/baselines/reference/constDeclarations-access.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/constDeclarations-access.ts] //// //// [file1.ts] - const x = 0 //// [file2.ts] diff --git a/tests/baselines/reference/constDeclarations-access2.errors.txt b/tests/baselines/reference/constDeclarations-access2.errors.txt index 16335bfa59cbe..dc8b4d5b90b86 100644 --- a/tests/baselines/reference/constDeclarations-access2.errors.txt +++ b/tests/baselines/reference/constDeclarations-access2.errors.txt @@ -1,3 +1,4 @@ +tests/cases/compiler/constDeclarations-access2.ts(4,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(5,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(6,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(7,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. @@ -9,16 +10,14 @@ tests/cases/compiler/constDeclarations-access2.ts(12,1): error TS2540: Cannot as tests/cases/compiler/constDeclarations-access2.ts(13,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(14,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(15,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access2.ts(16,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access2.ts(17,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(18,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access2.ts(19,1): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access2.ts(19,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access2.ts(20,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access2.ts(21,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access2.ts(23,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access2.ts(22,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. ==== tests/cases/compiler/constDeclarations-access2.ts (17 errors) ==== - const x = 0 // Errors diff --git a/tests/baselines/reference/constDeclarations-access2.js b/tests/baselines/reference/constDeclarations-access2.js index ae8dae7064605..33bca0691bf8e 100644 --- a/tests/baselines/reference/constDeclarations-access2.js +++ b/tests/baselines/reference/constDeclarations-access2.js @@ -1,5 +1,4 @@ //// [constDeclarations-access2.ts] - const x = 0 // Errors diff --git a/tests/baselines/reference/constDeclarations-access3.errors.txt b/tests/baselines/reference/constDeclarations-access3.errors.txt index 03ea2d29bba92..dd55ef9166d50 100644 --- a/tests/baselines/reference/constDeclarations-access3.errors.txt +++ b/tests/baselines/reference/constDeclarations-access3.errors.txt @@ -1,3 +1,5 @@ +tests/cases/compiler/constDeclarations-access3.ts(6,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(7,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(8,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(9,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(10,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. @@ -8,19 +10,15 @@ tests/cases/compiler/constDeclarations-access3.ts(14,3): error TS2540: Cannot as tests/cases/compiler/constDeclarations-access3.ts(15,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(16,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(17,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(18,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access3.ts(19,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(21,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(22,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(23,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(24,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(26,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access3.ts(28,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(20,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(21,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(22,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(24,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access3.ts(26,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. ==== tests/cases/compiler/constDeclarations-access3.ts (18 errors) ==== - - module M { export const x = 0; } diff --git a/tests/baselines/reference/constDeclarations-access3.js b/tests/baselines/reference/constDeclarations-access3.js index 9140da965c32a..945c688321361 100644 --- a/tests/baselines/reference/constDeclarations-access3.js +++ b/tests/baselines/reference/constDeclarations-access3.js @@ -1,6 +1,4 @@ //// [constDeclarations-access3.ts] - - module M { export const x = 0; } diff --git a/tests/baselines/reference/constDeclarations-access4.errors.txt b/tests/baselines/reference/constDeclarations-access4.errors.txt index a4111c2d7023c..5bc4f1faddaca 100644 --- a/tests/baselines/reference/constDeclarations-access4.errors.txt +++ b/tests/baselines/reference/constDeclarations-access4.errors.txt @@ -1,3 +1,5 @@ +tests/cases/compiler/constDeclarations-access4.ts(6,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(7,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(8,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(9,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(10,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. @@ -8,19 +10,15 @@ tests/cases/compiler/constDeclarations-access4.ts(14,3): error TS2540: Cannot as tests/cases/compiler/constDeclarations-access4.ts(15,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(16,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(17,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(18,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/constDeclarations-access4.ts(19,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(21,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(22,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(23,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(24,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(26,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-access4.ts(28,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(20,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(21,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(22,5): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(24,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-access4.ts(26,3): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. ==== tests/cases/compiler/constDeclarations-access4.ts (18 errors) ==== - - declare module M { const x: number; } diff --git a/tests/baselines/reference/constDeclarations-access4.js b/tests/baselines/reference/constDeclarations-access4.js index 608d950526a6e..851322ceea5bc 100644 --- a/tests/baselines/reference/constDeclarations-access4.js +++ b/tests/baselines/reference/constDeclarations-access4.js @@ -1,6 +1,4 @@ //// [constDeclarations-access4.ts] - - declare module M { const x: number; } diff --git a/tests/baselines/reference/constDeclarations-access5.errors.txt b/tests/baselines/reference/constDeclarations-access5.errors.txt index 316465e80b85b..61d579dccc5fd 100644 --- a/tests/baselines/reference/constDeclarations-access5.errors.txt +++ b/tests/baselines/reference/constDeclarations-access5.errors.txt @@ -97,7 +97,5 @@ tests/cases/compiler/constDeclarations_access_2.ts(24,3): error TS2540: Cannot a m.x.toString(); ==== tests/cases/compiler/constDeclarations_access_1.ts (0 errors) ==== - - export const x = 0; \ No newline at end of file diff --git a/tests/baselines/reference/constDeclarations-access5.js b/tests/baselines/reference/constDeclarations-access5.js index f02b9611541f6..cb5d24477187c 100644 --- a/tests/baselines/reference/constDeclarations-access5.js +++ b/tests/baselines/reference/constDeclarations-access5.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/constDeclarations-access5.ts] //// //// [constDeclarations_access_1.ts] - - export const x = 0; //// [constDeclarations_access_2.ts] diff --git a/tests/baselines/reference/constDeclarations-ambient-errors.errors.txt b/tests/baselines/reference/constDeclarations-ambient-errors.errors.txt index 2ecc7fc7ed322..979448abf7296 100644 --- a/tests/baselines/reference/constDeclarations-ambient-errors.errors.txt +++ b/tests/baselines/reference/constDeclarations-ambient-errors.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/constDeclarations-ambient-errors.ts(3,27): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/compiler/constDeclarations-ambient-errors.ts(4,26): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/compiler/constDeclarations-ambient-errors.ts(5,20): error TS1254: A 'const' initializer in an ambient context must be a string or numeric literal. -tests/cases/compiler/constDeclarations-ambient-errors.ts(5,37): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/compiler/constDeclarations-ambient-errors.ts(5,51): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/compiler/constDeclarations-ambient-errors.ts(9,22): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(2,27): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(3,26): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(4,20): error TS1254: A 'const' initializer in an ambient context must be a string or numeric literal. +tests/cases/compiler/constDeclarations-ambient-errors.ts(4,37): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(4,51): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/compiler/constDeclarations-ambient-errors.ts(8,22): error TS1039: Initializers are not allowed in ambient contexts. ==== tests/cases/compiler/constDeclarations-ambient-errors.ts (6 errors) ==== - // error: no intialization expected in ambient declarations declare const c1: boolean = true; ~ diff --git a/tests/baselines/reference/constDeclarations-ambient-errors.js b/tests/baselines/reference/constDeclarations-ambient-errors.js index e6e7ac1fb1630..7e506c85cf10c 100644 --- a/tests/baselines/reference/constDeclarations-ambient-errors.js +++ b/tests/baselines/reference/constDeclarations-ambient-errors.js @@ -1,5 +1,4 @@ //// [constDeclarations-ambient-errors.ts] - // error: no intialization expected in ambient declarations declare const c1: boolean = true; declare const c2: number = 0; diff --git a/tests/baselines/reference/constDeclarations-ambient.js b/tests/baselines/reference/constDeclarations-ambient.js index dd78f73051aa4..eb31d0c61d8a5 100644 --- a/tests/baselines/reference/constDeclarations-ambient.js +++ b/tests/baselines/reference/constDeclarations-ambient.js @@ -1,5 +1,4 @@ //// [constDeclarations-ambient.ts] - // No error declare const c1: boolean; declare const c2: number; diff --git a/tests/baselines/reference/constDeclarations-ambient.symbols b/tests/baselines/reference/constDeclarations-ambient.symbols index 87dfecab0c006..e9a41a706c6f4 100644 --- a/tests/baselines/reference/constDeclarations-ambient.symbols +++ b/tests/baselines/reference/constDeclarations-ambient.symbols @@ -1,23 +1,22 @@ === tests/cases/compiler/constDeclarations-ambient.ts === - // No error declare const c1: boolean; ->c1 : Symbol(c1, Decl(constDeclarations-ambient.ts, 2, 13)) +>c1 : Symbol(c1, Decl(constDeclarations-ambient.ts, 1, 13)) declare const c2: number; ->c2 : Symbol(c2, Decl(constDeclarations-ambient.ts, 3, 13)) +>c2 : Symbol(c2, Decl(constDeclarations-ambient.ts, 2, 13)) declare const c3, c4 :string, c5: any; ->c3 : Symbol(c3, Decl(constDeclarations-ambient.ts, 4, 13)) ->c4 : Symbol(c4, Decl(constDeclarations-ambient.ts, 4, 17)) ->c5 : Symbol(c5, Decl(constDeclarations-ambient.ts, 4, 29)) +>c3 : Symbol(c3, Decl(constDeclarations-ambient.ts, 3, 13)) +>c4 : Symbol(c4, Decl(constDeclarations-ambient.ts, 3, 17)) +>c5 : Symbol(c5, Decl(constDeclarations-ambient.ts, 3, 29)) declare module M { ->M : Symbol(M, Decl(constDeclarations-ambient.ts, 4, 38)) +>M : Symbol(M, Decl(constDeclarations-ambient.ts, 3, 38)) const c6; ->c6 : Symbol(c6, Decl(constDeclarations-ambient.ts, 7, 9)) +>c6 : Symbol(c6, Decl(constDeclarations-ambient.ts, 6, 9)) const c7: number; ->c7 : Symbol(c7, Decl(constDeclarations-ambient.ts, 8, 9)) +>c7 : Symbol(c7, Decl(constDeclarations-ambient.ts, 7, 9)) } diff --git a/tests/baselines/reference/constDeclarations-ambient.types b/tests/baselines/reference/constDeclarations-ambient.types index 0ab2d4b700a69..f9db4f11d4937 100644 --- a/tests/baselines/reference/constDeclarations-ambient.types +++ b/tests/baselines/reference/constDeclarations-ambient.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations-ambient.ts === - // No error declare const c1: boolean; >c1 : boolean diff --git a/tests/baselines/reference/constDeclarations-errors.errors.txt b/tests/baselines/reference/constDeclarations-errors.errors.txt index 14a3de1bf8189..525795617072b 100644 --- a/tests/baselines/reference/constDeclarations-errors.errors.txt +++ b/tests/baselines/reference/constDeclarations-errors.errors.txt @@ -1,16 +1,15 @@ +tests/cases/compiler/constDeclarations-errors.ts(2,7): error TS1155: 'const' declarations must be initialized. tests/cases/compiler/constDeclarations-errors.ts(3,7): error TS1155: 'const' declarations must be initialized. tests/cases/compiler/constDeclarations-errors.ts(4,7): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(5,7): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(5,11): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(5,15): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(5,27): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(10,27): error TS2540: Cannot assign to 'c8' because it is a constant or a read-only property. -tests/cases/compiler/constDeclarations-errors.ts(13,11): error TS1155: 'const' declarations must be initialized. -tests/cases/compiler/constDeclarations-errors.ts(16,20): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(4,11): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(4,15): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(4,27): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(9,27): error TS2540: Cannot assign to 'c8' because it is a constant or a read-only property. +tests/cases/compiler/constDeclarations-errors.ts(12,11): error TS1155: 'const' declarations must be initialized. +tests/cases/compiler/constDeclarations-errors.ts(15,20): error TS1155: 'const' declarations must be initialized. ==== tests/cases/compiler/constDeclarations-errors.ts (9 errors) ==== - // error, missing intialicer const c1; ~~ diff --git a/tests/baselines/reference/constDeclarations-errors.js b/tests/baselines/reference/constDeclarations-errors.js index e7143f2564ae7..afd0fcacf2858 100644 --- a/tests/baselines/reference/constDeclarations-errors.js +++ b/tests/baselines/reference/constDeclarations-errors.js @@ -1,5 +1,4 @@ //// [constDeclarations-errors.ts] - // error, missing intialicer const c1; const c2: number; diff --git a/tests/baselines/reference/constDeclarations-es5.js b/tests/baselines/reference/constDeclarations-es5.js index 736260ad10251..f8d8cdeac9020 100644 --- a/tests/baselines/reference/constDeclarations-es5.js +++ b/tests/baselines/reference/constDeclarations-es5.js @@ -1,5 +1,4 @@ //// [constDeclarations-es5.ts] - const z7 = false; const z8: number = 23; const z9 = 0, z10 :string = "", z11 = null; diff --git a/tests/baselines/reference/constDeclarations-es5.symbols b/tests/baselines/reference/constDeclarations-es5.symbols index 116dd06573b88..93a7d90ec4a20 100644 --- a/tests/baselines/reference/constDeclarations-es5.symbols +++ b/tests/baselines/reference/constDeclarations-es5.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/constDeclarations-es5.ts === - const z7 = false; ->z7 : Symbol(z7, Decl(constDeclarations-es5.ts, 1, 5)) +>z7 : Symbol(z7, Decl(constDeclarations-es5.ts, 0, 5)) const z8: number = 23; ->z8 : Symbol(z8, Decl(constDeclarations-es5.ts, 2, 5)) +>z8 : Symbol(z8, Decl(constDeclarations-es5.ts, 1, 5)) const z9 = 0, z10 :string = "", z11 = null; ->z9 : Symbol(z9, Decl(constDeclarations-es5.ts, 3, 5)) ->z10 : Symbol(z10, Decl(constDeclarations-es5.ts, 3, 13)) ->z11 : Symbol(z11, Decl(constDeclarations-es5.ts, 3, 31)) +>z9 : Symbol(z9, Decl(constDeclarations-es5.ts, 2, 5)) +>z10 : Symbol(z10, Decl(constDeclarations-es5.ts, 2, 13)) +>z11 : Symbol(z11, Decl(constDeclarations-es5.ts, 2, 31)) diff --git a/tests/baselines/reference/constDeclarations-es5.types b/tests/baselines/reference/constDeclarations-es5.types index e801607727edb..49e9720784558 100644 --- a/tests/baselines/reference/constDeclarations-es5.types +++ b/tests/baselines/reference/constDeclarations-es5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations-es5.ts === - const z7 = false; >z7 : false >false : false diff --git a/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt index 93a5644abb51c..976732f245f79 100644 --- a/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt +++ b/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt @@ -1,16 +1,15 @@ -tests/cases/compiler/constDeclarations-invalidContexts.ts(4,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(6,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(9,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(12,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(16,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. -tests/cases/compiler/constDeclarations-invalidContexts.ts(20,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(23,5): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(26,12): error TS1156: 'const' declarations can only be declared inside a block. -tests/cases/compiler/constDeclarations-invalidContexts.ts(29,29): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(3,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(5,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(8,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(11,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(15,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/constDeclarations-invalidContexts.ts(19,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(22,5): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(25,12): error TS1156: 'const' declarations can only be declared inside a block. +tests/cases/compiler/constDeclarations-invalidContexts.ts(28,29): error TS1156: 'const' declarations can only be declared inside a block. ==== tests/cases/compiler/constDeclarations-invalidContexts.ts (9 errors) ==== - // Errors, const must be defined inside a block if (true) const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations-invalidContexts.js b/tests/baselines/reference/constDeclarations-invalidContexts.js index a9dc1b471454d..2a3dad8df5057 100644 --- a/tests/baselines/reference/constDeclarations-invalidContexts.js +++ b/tests/baselines/reference/constDeclarations-invalidContexts.js @@ -1,5 +1,4 @@ //// [constDeclarations-invalidContexts.ts] - // Errors, const must be defined inside a block if (true) const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations-scopes.errors.txt b/tests/baselines/reference/constDeclarations-scopes.errors.txt index 905988bf7840a..064ad9aaaf838 100644 --- a/tests/baselines/reference/constDeclarations-scopes.errors.txt +++ b/tests/baselines/reference/constDeclarations-scopes.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/constDeclarations-scopes.ts(13,5): error TS7027: Unreachable code detected. -tests/cases/compiler/constDeclarations-scopes.ts(22,1): error TS7027: Unreachable code detected. -tests/cases/compiler/constDeclarations-scopes.ts(28,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/constDeclarations-scopes.ts(12,5): error TS7027: Unreachable code detected. +tests/cases/compiler/constDeclarations-scopes.ts(21,1): error TS7027: Unreachable code detected. +tests/cases/compiler/constDeclarations-scopes.ts(27,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. ==== tests/cases/compiler/constDeclarations-scopes.ts (3 errors) ==== - // global const c = "string"; diff --git a/tests/baselines/reference/constDeclarations-scopes.js b/tests/baselines/reference/constDeclarations-scopes.js index b144b4f83a553..a40edb87ec99c 100644 --- a/tests/baselines/reference/constDeclarations-scopes.js +++ b/tests/baselines/reference/constDeclarations-scopes.js @@ -1,5 +1,4 @@ //// [constDeclarations-scopes.ts] - // global const c = "string"; diff --git a/tests/baselines/reference/constDeclarations-scopes2.js b/tests/baselines/reference/constDeclarations-scopes2.js index d407cf56801bd..03d78f9030e38 100644 --- a/tests/baselines/reference/constDeclarations-scopes2.js +++ b/tests/baselines/reference/constDeclarations-scopes2.js @@ -1,5 +1,4 @@ //// [constDeclarations-scopes2.ts] - // global const c = "string"; diff --git a/tests/baselines/reference/constDeclarations-scopes2.symbols b/tests/baselines/reference/constDeclarations-scopes2.symbols index 15e466e8ea183..60eb7606d0e8c 100644 --- a/tests/baselines/reference/constDeclarations-scopes2.symbols +++ b/tests/baselines/reference/constDeclarations-scopes2.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/constDeclarations-scopes2.ts === - // global const c = "string"; ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 2, 5)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 1, 5)) var n: number; ->n : Symbol(n, Decl(constDeclarations-scopes2.ts, 4, 3)) +>n : Symbol(n, Decl(constDeclarations-scopes2.ts, 3, 3)) var b: boolean; ->b : Symbol(b, Decl(constDeclarations-scopes2.ts, 5, 3)) +>b : Symbol(b, Decl(constDeclarations-scopes2.ts, 4, 3)) // for scope for (const c = 0; c < 10; n = c ) { ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 8, 10)) ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 8, 10)) ->n : Symbol(n, Decl(constDeclarations-scopes2.ts, 4, 3)) ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 8, 10)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 7, 10)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 7, 10)) +>n : Symbol(n, Decl(constDeclarations-scopes2.ts, 3, 3)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 7, 10)) // for block const c = false; ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 10, 9)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 9, 9)) b = c; ->b : Symbol(b, Decl(constDeclarations-scopes2.ts, 5, 3)) ->c : Symbol(c, Decl(constDeclarations-scopes2.ts, 10, 9)) +>b : Symbol(b, Decl(constDeclarations-scopes2.ts, 4, 3)) +>c : Symbol(c, Decl(constDeclarations-scopes2.ts, 9, 9)) } diff --git a/tests/baselines/reference/constDeclarations-scopes2.types b/tests/baselines/reference/constDeclarations-scopes2.types index 9834c6bb16e1d..98e27785563f9 100644 --- a/tests/baselines/reference/constDeclarations-scopes2.types +++ b/tests/baselines/reference/constDeclarations-scopes2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations-scopes2.ts === - // global const c = "string"; >c : "string" diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition.errors.txt b/tests/baselines/reference/constDeclarations-useBeforeDefinition.errors.txt index 97cf58c6e9d23..a4d33065b5946 100644 --- a/tests/baselines/reference/constDeclarations-useBeforeDefinition.errors.txt +++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/constDeclarations-useBeforeDefinition.ts(3,5): error TS2448: Block-scoped variable 'c1' used before its declaration. -tests/cases/compiler/constDeclarations-useBeforeDefinition.ts(9,5): error TS2448: Block-scoped variable 'v1' used before its declaration. +tests/cases/compiler/constDeclarations-useBeforeDefinition.ts(2,5): error TS2448: Block-scoped variable 'c1' used before its declaration. +tests/cases/compiler/constDeclarations-useBeforeDefinition.ts(8,5): error TS2448: Block-scoped variable 'v1' used before its declaration. ==== tests/cases/compiler/constDeclarations-useBeforeDefinition.ts (2 errors) ==== - { c1; ~~ diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition.js b/tests/baselines/reference/constDeclarations-useBeforeDefinition.js index 4fe0e64f27542..251526c017495 100644 --- a/tests/baselines/reference/constDeclarations-useBeforeDefinition.js +++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition.js @@ -1,5 +1,4 @@ //// [constDeclarations-useBeforeDefinition.ts] - { c1; const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt index a4d28f5187857..bbcc3b2c8f8be 100644 --- a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt +++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/file1.ts(2,1): error TS2448: Block-scoped variable 'c' used before its declaration. +tests/cases/compiler/file1.ts(1,1): error TS2448: Block-scoped variable 'c' used before its declaration. ==== tests/cases/compiler/file1.ts (1 errors) ==== - c; ~ !!! error TS2448: Block-scoped variable 'c' used before its declaration. diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.js b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.js index 7d1f4cf572584..022bd25409a31 100644 --- a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.js +++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/constDeclarations-useBeforeDefinition2.ts] //// //// [file1.ts] - c; //// [file2.ts] diff --git a/tests/baselines/reference/constDeclarations-validContexts.errors.txt b/tests/baselines/reference/constDeclarations-validContexts.errors.txt index 65e80e7c6fd0d..58ad3ee99033a 100644 --- a/tests/baselines/reference/constDeclarations-validContexts.errors.txt +++ b/tests/baselines/reference/constDeclarations-validContexts.errors.txt @@ -1,9 +1,7 @@ -tests/cases/compiler/constDeclarations-validContexts.ts(20,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/constDeclarations-validContexts.ts(18,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. ==== tests/cases/compiler/constDeclarations-validContexts.ts (1 errors) ==== - - // Control flow statements with blocks if (true) { const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations-validContexts.js b/tests/baselines/reference/constDeclarations-validContexts.js index 7d3269c66832d..dba61fec63520 100644 --- a/tests/baselines/reference/constDeclarations-validContexts.js +++ b/tests/baselines/reference/constDeclarations-validContexts.js @@ -1,6 +1,4 @@ //// [constDeclarations-validContexts.ts] - - // Control flow statements with blocks if (true) { const c1 = 0; diff --git a/tests/baselines/reference/constDeclarations.js b/tests/baselines/reference/constDeclarations.js index 00d0a61ef9b7b..273651179429e 100644 --- a/tests/baselines/reference/constDeclarations.js +++ b/tests/baselines/reference/constDeclarations.js @@ -1,5 +1,4 @@ //// [constDeclarations.ts] - // No error const c1 = false; const c2: number = 23; diff --git a/tests/baselines/reference/constDeclarations.symbols b/tests/baselines/reference/constDeclarations.symbols index 01653620dd06e..2ec87cedb7e55 100644 --- a/tests/baselines/reference/constDeclarations.symbols +++ b/tests/baselines/reference/constDeclarations.symbols @@ -1,26 +1,25 @@ === tests/cases/compiler/constDeclarations.ts === - // No error const c1 = false; ->c1 : Symbol(c1, Decl(constDeclarations.ts, 2, 5)) +>c1 : Symbol(c1, Decl(constDeclarations.ts, 1, 5)) const c2: number = 23; ->c2 : Symbol(c2, Decl(constDeclarations.ts, 3, 5)) +>c2 : Symbol(c2, Decl(constDeclarations.ts, 2, 5)) const c3 = 0, c4 :string = "", c5 = null; ->c3 : Symbol(c3, Decl(constDeclarations.ts, 4, 5)) ->c4 : Symbol(c4, Decl(constDeclarations.ts, 4, 13)) ->c5 : Symbol(c5, Decl(constDeclarations.ts, 4, 30)) +>c3 : Symbol(c3, Decl(constDeclarations.ts, 3, 5)) +>c4 : Symbol(c4, Decl(constDeclarations.ts, 3, 13)) +>c5 : Symbol(c5, Decl(constDeclarations.ts, 3, 30)) for(const c4 = 0; c4 < 9; ) { break; } ->c4 : Symbol(c4, Decl(constDeclarations.ts, 7, 9)) ->c4 : Symbol(c4, Decl(constDeclarations.ts, 7, 9)) +>c4 : Symbol(c4, Decl(constDeclarations.ts, 6, 9)) +>c4 : Symbol(c4, Decl(constDeclarations.ts, 6, 9)) for(const c5 = 0, c6 = 0; c5 < c6; ) { break; } ->c5 : Symbol(c5, Decl(constDeclarations.ts, 10, 9)) ->c6 : Symbol(c6, Decl(constDeclarations.ts, 10, 17)) ->c5 : Symbol(c5, Decl(constDeclarations.ts, 10, 9)) ->c6 : Symbol(c6, Decl(constDeclarations.ts, 10, 17)) +>c5 : Symbol(c5, Decl(constDeclarations.ts, 9, 9)) +>c6 : Symbol(c6, Decl(constDeclarations.ts, 9, 17)) +>c5 : Symbol(c5, Decl(constDeclarations.ts, 9, 9)) +>c6 : Symbol(c6, Decl(constDeclarations.ts, 9, 17)) diff --git a/tests/baselines/reference/constDeclarations.types b/tests/baselines/reference/constDeclarations.types index 0fa7893529fe0..75a9dc7556afc 100644 --- a/tests/baselines/reference/constDeclarations.types +++ b/tests/baselines/reference/constDeclarations.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations.ts === - // No error const c1 = false; >c1 : false diff --git a/tests/baselines/reference/constDeclarations2.js b/tests/baselines/reference/constDeclarations2.js index 0c372924b50ca..e19022154c0a7 100644 --- a/tests/baselines/reference/constDeclarations2.js +++ b/tests/baselines/reference/constDeclarations2.js @@ -1,5 +1,4 @@ //// [constDeclarations2.ts] - // No error module M { export const c1 = false; diff --git a/tests/baselines/reference/constDeclarations2.symbols b/tests/baselines/reference/constDeclarations2.symbols index daeced31f77e1..2772c343e2e05 100644 --- a/tests/baselines/reference/constDeclarations2.symbols +++ b/tests/baselines/reference/constDeclarations2.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/constDeclarations2.ts === - // No error module M { >M : Symbol(M, Decl(constDeclarations2.ts, 0, 0)) export const c1 = false; ->c1 : Symbol(c1, Decl(constDeclarations2.ts, 3, 16)) +>c1 : Symbol(c1, Decl(constDeclarations2.ts, 2, 16)) export const c2: number = 23; ->c2 : Symbol(c2, Decl(constDeclarations2.ts, 4, 16)) +>c2 : Symbol(c2, Decl(constDeclarations2.ts, 3, 16)) export const c3 = 0, c4 :string = "", c5 = null; ->c3 : Symbol(c3, Decl(constDeclarations2.ts, 5, 16)) ->c4 : Symbol(c4, Decl(constDeclarations2.ts, 5, 24)) ->c5 : Symbol(c5, Decl(constDeclarations2.ts, 5, 41)) +>c3 : Symbol(c3, Decl(constDeclarations2.ts, 4, 16)) +>c4 : Symbol(c4, Decl(constDeclarations2.ts, 4, 24)) +>c5 : Symbol(c5, Decl(constDeclarations2.ts, 4, 41)) } diff --git a/tests/baselines/reference/constDeclarations2.types b/tests/baselines/reference/constDeclarations2.types index 54a273dfb4d41..fdf127cbab49c 100644 --- a/tests/baselines/reference/constDeclarations2.types +++ b/tests/baselines/reference/constDeclarations2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constDeclarations2.ts === - // No error module M { >M : typeof M diff --git a/tests/baselines/reference/constEnum1.js b/tests/baselines/reference/constEnum1.js index d5ccede3ff1f4..7065c12d8cf73 100644 --- a/tests/baselines/reference/constEnum1.js +++ b/tests/baselines/reference/constEnum1.js @@ -1,5 +1,4 @@ //// [constEnum1.ts] - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. diff --git a/tests/baselines/reference/constEnum1.symbols b/tests/baselines/reference/constEnum1.symbols index e94ed0a472280..f7593863e8c8f 100644 --- a/tests/baselines/reference/constEnum1.symbols +++ b/tests/baselines/reference/constEnum1.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/constEnums/constEnum1.ts === - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. @@ -8,33 +7,33 @@ const enum E { >E : Symbol(E, Decl(constEnum1.ts, 0, 0)) a = 10, ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) b = a, ->b : Symbol(E.b, Decl(constEnum1.ts, 6, 11)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>b : Symbol(E.b, Decl(constEnum1.ts, 5, 11)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) c = (a+1), ->c : Symbol(E.c, Decl(constEnum1.ts, 7, 10)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>c : Symbol(E.c, Decl(constEnum1.ts, 6, 10)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) e, ->e : Symbol(E.e, Decl(constEnum1.ts, 8, 14)) +>e : Symbol(E.e, Decl(constEnum1.ts, 7, 14)) d = ~e, ->d : Symbol(E.d, Decl(constEnum1.ts, 9, 6)) ->e : Symbol(E.e, Decl(constEnum1.ts, 8, 14)) +>d : Symbol(E.d, Decl(constEnum1.ts, 8, 6)) +>e : Symbol(E.e, Decl(constEnum1.ts, 7, 14)) f = a << 2 >> 1, ->f : Symbol(E.f, Decl(constEnum1.ts, 10, 11)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>f : Symbol(E.f, Decl(constEnum1.ts, 9, 11)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) g = a << 2 >>> 1, ->g : Symbol(E.g, Decl(constEnum1.ts, 11, 20)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) +>g : Symbol(E.g, Decl(constEnum1.ts, 10, 20)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) h = a | b ->h : Symbol(E.h, Decl(constEnum1.ts, 12, 21)) ->a : Symbol(E.a, Decl(constEnum1.ts, 5, 14)) ->b : Symbol(E.b, Decl(constEnum1.ts, 6, 11)) +>h : Symbol(E.h, Decl(constEnum1.ts, 11, 21)) +>a : Symbol(E.a, Decl(constEnum1.ts, 4, 14)) +>b : Symbol(E.b, Decl(constEnum1.ts, 5, 11)) } diff --git a/tests/baselines/reference/constEnum1.types b/tests/baselines/reference/constEnum1.types index 17f6f5de27875..9df7eff9515cc 100644 --- a/tests/baselines/reference/constEnum1.types +++ b/tests/baselines/reference/constEnum1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/constEnums/constEnum1.ts === - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. diff --git a/tests/baselines/reference/constEnum2.errors.txt b/tests/baselines/reference/constEnum2.errors.txt index f0cac0c2f5d27..cfec4d9055b42 100644 --- a/tests/baselines/reference/constEnum2.errors.txt +++ b/tests/baselines/reference/constEnum2.errors.txt @@ -1,11 +1,10 @@ +tests/cases/conformance/constEnums/constEnum2.ts(10,9): error TS2474: In 'const' enum declarations member initializer must be constant expression. tests/cases/conformance/constEnums/constEnum2.ts(11,9): error TS2474: In 'const' enum declarations member initializer must be constant expression. +tests/cases/conformance/constEnums/constEnum2.ts(12,5): error TS1005: ',' expected. tests/cases/conformance/constEnums/constEnum2.ts(12,9): error TS2474: In 'const' enum declarations member initializer must be constant expression. -tests/cases/conformance/constEnums/constEnum2.ts(13,5): error TS1005: ',' expected. -tests/cases/conformance/constEnums/constEnum2.ts(13,9): error TS2474: In 'const' enum declarations member initializer must be constant expression. ==== tests/cases/conformance/constEnums/constEnum2.ts (4 errors) ==== - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. diff --git a/tests/baselines/reference/constEnum2.js b/tests/baselines/reference/constEnum2.js index c0c640b87fda4..66a44f6a1befd 100644 --- a/tests/baselines/reference/constEnum2.js +++ b/tests/baselines/reference/constEnum2.js @@ -1,5 +1,4 @@ //// [constEnum2.ts] - // An enum declaration that specifies a const modifier is a constant enum declaration. // In a constant enum declaration, all members must have constant values and // it is an error for a member declaration to specify an expression that isn't classified as a constant enum expression. diff --git a/tests/baselines/reference/constEnumDeclarations.js b/tests/baselines/reference/constEnumDeclarations.js index 1cbacb13bbd5f..f24769c462067 100644 --- a/tests/baselines/reference/constEnumDeclarations.js +++ b/tests/baselines/reference/constEnumDeclarations.js @@ -1,5 +1,4 @@ //// [constEnumDeclarations.ts] - const enum E { A = 1, B = 2, diff --git a/tests/baselines/reference/constEnumDeclarations.symbols b/tests/baselines/reference/constEnumDeclarations.symbols index 72b833e4faecf..9809e6a2c56ce 100644 --- a/tests/baselines/reference/constEnumDeclarations.symbols +++ b/tests/baselines/reference/constEnumDeclarations.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/constEnumDeclarations.ts === - const enum E { >E : Symbol(E, Decl(constEnumDeclarations.ts, 0, 0)) A = 1, ->A : Symbol(E.A, Decl(constEnumDeclarations.ts, 1, 14)) +>A : Symbol(E.A, Decl(constEnumDeclarations.ts, 0, 14)) B = 2, ->B : Symbol(E.B, Decl(constEnumDeclarations.ts, 2, 10)) +>B : Symbol(E.B, Decl(constEnumDeclarations.ts, 1, 10)) C = A | B ->C : Symbol(E.C, Decl(constEnumDeclarations.ts, 3, 10)) ->A : Symbol(E.A, Decl(constEnumDeclarations.ts, 1, 14)) ->B : Symbol(E.B, Decl(constEnumDeclarations.ts, 2, 10)) +>C : Symbol(E.C, Decl(constEnumDeclarations.ts, 2, 10)) +>A : Symbol(E.A, Decl(constEnumDeclarations.ts, 0, 14)) +>B : Symbol(E.B, Decl(constEnumDeclarations.ts, 1, 10)) } const enum E2 { ->E2 : Symbol(E2, Decl(constEnumDeclarations.ts, 5, 1)) +>E2 : Symbol(E2, Decl(constEnumDeclarations.ts, 4, 1)) A = 1, ->A : Symbol(E2.A, Decl(constEnumDeclarations.ts, 7, 15)) +>A : Symbol(E2.A, Decl(constEnumDeclarations.ts, 6, 15)) B, ->B : Symbol(E2.B, Decl(constEnumDeclarations.ts, 8, 10)) +>B : Symbol(E2.B, Decl(constEnumDeclarations.ts, 7, 10)) C ->C : Symbol(E2.C, Decl(constEnumDeclarations.ts, 9, 6)) +>C : Symbol(E2.C, Decl(constEnumDeclarations.ts, 8, 6)) } diff --git a/tests/baselines/reference/constEnumDeclarations.types b/tests/baselines/reference/constEnumDeclarations.types index 1f86028b3850d..c8bf3698d1933 100644 --- a/tests/baselines/reference/constEnumDeclarations.types +++ b/tests/baselines/reference/constEnumDeclarations.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constEnumDeclarations.ts === - const enum E { >E : E diff --git a/tests/baselines/reference/constEnumMergingWithValues1.js b/tests/baselines/reference/constEnumMergingWithValues1.js index 1fdfb3fb1dd8d..a9c1eef8de82c 100644 --- a/tests/baselines/reference/constEnumMergingWithValues1.js +++ b/tests/baselines/reference/constEnumMergingWithValues1.js @@ -1,5 +1,4 @@ //// [m1.ts] - function foo() {} module foo { const enum E { X } diff --git a/tests/baselines/reference/constEnumMergingWithValues1.symbols b/tests/baselines/reference/constEnumMergingWithValues1.symbols index ba655091dedc1..9be1d9698bf6f 100644 --- a/tests/baselines/reference/constEnumMergingWithValues1.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues1.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/m1.ts === - function foo() {} ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 17)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 17)) module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 17)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 17)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 2, 12)) ->X : Symbol(E.X, Decl(m1.ts, 3, 18)) +>E : Symbol(E, Decl(m1.ts, 1, 12)) +>X : Symbol(E.X, Decl(m1.ts, 2, 18)) } export = foo ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 17)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 17)) diff --git a/tests/baselines/reference/constEnumMergingWithValues1.types b/tests/baselines/reference/constEnumMergingWithValues1.types index c5b1a82a5a871..44d6e5c9ac395 100644 --- a/tests/baselines/reference/constEnumMergingWithValues1.types +++ b/tests/baselines/reference/constEnumMergingWithValues1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - function foo() {} >foo : typeof foo diff --git a/tests/baselines/reference/constEnumMergingWithValues2.js b/tests/baselines/reference/constEnumMergingWithValues2.js index 07249ddcc5f43..bd14cf1eda1fa 100644 --- a/tests/baselines/reference/constEnumMergingWithValues2.js +++ b/tests/baselines/reference/constEnumMergingWithValues2.js @@ -1,5 +1,4 @@ //// [m1.ts] - class foo {} module foo { const enum E { X } diff --git a/tests/baselines/reference/constEnumMergingWithValues2.symbols b/tests/baselines/reference/constEnumMergingWithValues2.symbols index a7744499f4990..60bfbd64753eb 100644 --- a/tests/baselines/reference/constEnumMergingWithValues2.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues2.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/m1.ts === - class foo {} ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 12)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 12)) module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 12)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 12)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 2, 12)) ->X : Symbol(E.X, Decl(m1.ts, 3, 18)) +>E : Symbol(E, Decl(m1.ts, 1, 12)) +>X : Symbol(E.X, Decl(m1.ts, 2, 18)) } export = foo ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 12)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 12)) diff --git a/tests/baselines/reference/constEnumMergingWithValues2.types b/tests/baselines/reference/constEnumMergingWithValues2.types index ab2372cbae9a3..88a2413094b29 100644 --- a/tests/baselines/reference/constEnumMergingWithValues2.types +++ b/tests/baselines/reference/constEnumMergingWithValues2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - class foo {} >foo : foo diff --git a/tests/baselines/reference/constEnumMergingWithValues3.js b/tests/baselines/reference/constEnumMergingWithValues3.js index c2cafb2a5f1ea..7e105976d2d04 100644 --- a/tests/baselines/reference/constEnumMergingWithValues3.js +++ b/tests/baselines/reference/constEnumMergingWithValues3.js @@ -1,5 +1,4 @@ //// [m1.ts] - enum foo { A } module foo { const enum E { X } diff --git a/tests/baselines/reference/constEnumMergingWithValues3.symbols b/tests/baselines/reference/constEnumMergingWithValues3.symbols index 816919c6805ac..dfb5cc7bd4041 100644 --- a/tests/baselines/reference/constEnumMergingWithValues3.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues3.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/m1.ts === - enum foo { A } ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 14)) ->A : Symbol(foo.A, Decl(m1.ts, 1, 10)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 14)) +>A : Symbol(foo.A, Decl(m1.ts, 0, 10)) module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 14)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 14)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 2, 12)) ->X : Symbol(E.X, Decl(m1.ts, 3, 18)) +>E : Symbol(E, Decl(m1.ts, 1, 12)) +>X : Symbol(E.X, Decl(m1.ts, 2, 18)) } export = foo ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 1, 14)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 0, 14)) diff --git a/tests/baselines/reference/constEnumMergingWithValues3.types b/tests/baselines/reference/constEnumMergingWithValues3.types index 392772860e406..6346f06ce816a 100644 --- a/tests/baselines/reference/constEnumMergingWithValues3.types +++ b/tests/baselines/reference/constEnumMergingWithValues3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - enum foo { A } >foo : foo >A : foo diff --git a/tests/baselines/reference/constEnumMergingWithValues4.js b/tests/baselines/reference/constEnumMergingWithValues4.js index c297b83465418..3d70f5ad2c940 100644 --- a/tests/baselines/reference/constEnumMergingWithValues4.js +++ b/tests/baselines/reference/constEnumMergingWithValues4.js @@ -1,5 +1,4 @@ //// [m1.ts] - module foo { const enum E { X } } diff --git a/tests/baselines/reference/constEnumMergingWithValues4.symbols b/tests/baselines/reference/constEnumMergingWithValues4.symbols index a7135b53d57f8..b7ebcdb609aac 100644 --- a/tests/baselines/reference/constEnumMergingWithValues4.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues4.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/m1.ts === - module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 3, 1)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 2, 1)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 1, 12)) ->X : Symbol(E.X, Decl(m1.ts, 2, 18)) +>E : Symbol(E, Decl(m1.ts, 0, 12)) +>X : Symbol(E.X, Decl(m1.ts, 1, 18)) } module foo { ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 3, 1)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 2, 1)) var x = 1; ->x : Symbol(x, Decl(m1.ts, 6, 7)) +>x : Symbol(x, Decl(m1.ts, 5, 7)) } export = foo ->foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 3, 1)) +>foo : Symbol(foo, Decl(m1.ts, 0, 0), Decl(m1.ts, 2, 1)) diff --git a/tests/baselines/reference/constEnumMergingWithValues4.types b/tests/baselines/reference/constEnumMergingWithValues4.types index 8df07d3026d06..1e82bb4879111 100644 --- a/tests/baselines/reference/constEnumMergingWithValues4.types +++ b/tests/baselines/reference/constEnumMergingWithValues4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - module foo { >foo : typeof foo diff --git a/tests/baselines/reference/constEnumMergingWithValues5.js b/tests/baselines/reference/constEnumMergingWithValues5.js index 45aeff7bba35f..50a6e5c6925fa 100644 --- a/tests/baselines/reference/constEnumMergingWithValues5.js +++ b/tests/baselines/reference/constEnumMergingWithValues5.js @@ -1,5 +1,4 @@ //// [m1.ts] - module foo { const enum E { X } } diff --git a/tests/baselines/reference/constEnumMergingWithValues5.symbols b/tests/baselines/reference/constEnumMergingWithValues5.symbols index 257e1897e5c55..23c25fce8a013 100644 --- a/tests/baselines/reference/constEnumMergingWithValues5.symbols +++ b/tests/baselines/reference/constEnumMergingWithValues5.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/m1.ts === - module foo { >foo : Symbol(foo, Decl(m1.ts, 0, 0)) const enum E { X } ->E : Symbol(E, Decl(m1.ts, 1, 12)) ->X : Symbol(E.X, Decl(m1.ts, 2, 18)) +>E : Symbol(E, Decl(m1.ts, 0, 12)) +>X : Symbol(E.X, Decl(m1.ts, 1, 18)) } export = foo diff --git a/tests/baselines/reference/constEnumMergingWithValues5.types b/tests/baselines/reference/constEnumMergingWithValues5.types index 585363f4d9743..194e85e69658a 100644 --- a/tests/baselines/reference/constEnumMergingWithValues5.types +++ b/tests/baselines/reference/constEnumMergingWithValues5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - module foo { >foo : typeof foo diff --git a/tests/baselines/reference/constEnumPropertyAccess1.js b/tests/baselines/reference/constEnumPropertyAccess1.js index 114f1e1928ea4..66ac7b4a45982 100644 --- a/tests/baselines/reference/constEnumPropertyAccess1.js +++ b/tests/baselines/reference/constEnumPropertyAccess1.js @@ -1,5 +1,4 @@ //// [constEnumPropertyAccess1.ts] - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members diff --git a/tests/baselines/reference/constEnumPropertyAccess1.symbols b/tests/baselines/reference/constEnumPropertyAccess1.symbols index e5f2853f15738..63861a94ae1e6 100644 --- a/tests/baselines/reference/constEnumPropertyAccess1.symbols +++ b/tests/baselines/reference/constEnumPropertyAccess1.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/constEnums/constEnumPropertyAccess1.ts === - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members @@ -8,69 +7,69 @@ const enum G { >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) A = 1, ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) B = 2, ->B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) C = A + B, ->C : Symbol(G.C, Decl(constEnumPropertyAccess1.ts, 7, 10)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) ->B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>C : Symbol(G.C, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) +>B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) D = A * 2 ->D : Symbol(G.D, Decl(constEnumPropertyAccess1.ts, 8, 14)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>D : Symbol(G.D, Decl(constEnumPropertyAccess1.ts, 7, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) } var o: { ->o : Symbol(o, Decl(constEnumPropertyAccess1.ts, 12, 3)) +>o : Symbol(o, Decl(constEnumPropertyAccess1.ts, 11, 3)) [idx: number]: boolean ->idx : Symbol(idx, Decl(constEnumPropertyAccess1.ts, 13, 5)) +>idx : Symbol(idx, Decl(constEnumPropertyAccess1.ts, 12, 5)) } = { 1: true }; var a = G.A; ->a : Symbol(a, Decl(constEnumPropertyAccess1.ts, 18, 3)) ->G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>a : Symbol(a, Decl(constEnumPropertyAccess1.ts, 17, 3)) +>G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) var a1 = G["A"]; ->a1 : Symbol(a1, Decl(constEnumPropertyAccess1.ts, 19, 3)) +>a1 : Symbol(a1, Decl(constEnumPropertyAccess1.ts, 18, 3)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->"A" : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>"A" : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) var g = o[G.A]; ->g : Symbol(g, Decl(constEnumPropertyAccess1.ts, 20, 3)) ->o : Symbol(o, Decl(constEnumPropertyAccess1.ts, 12, 3)) ->G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>g : Symbol(g, Decl(constEnumPropertyAccess1.ts, 19, 3)) +>o : Symbol(o, Decl(constEnumPropertyAccess1.ts, 11, 3)) +>G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) class C { ->C : Symbol(C, Decl(constEnumPropertyAccess1.ts, 20, 15)) +>C : Symbol(C, Decl(constEnumPropertyAccess1.ts, 19, 15)) [G.A]() { } ->G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>G.A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 5, 14)) +>A : Symbol(G.A, Decl(constEnumPropertyAccess1.ts, 4, 14)) get [G.B]() { ->G.B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>G.B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) return true; } set [G.B](x: number) { } ->G.B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) +>G.B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) >G : Symbol(G, Decl(constEnumPropertyAccess1.ts, 0, 0)) ->B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 6, 10)) ->x : Symbol(x, Decl(constEnumPropertyAccess1.ts, 27, 14)) +>B : Symbol(G.B, Decl(constEnumPropertyAccess1.ts, 5, 10)) +>x : Symbol(x, Decl(constEnumPropertyAccess1.ts, 26, 14)) } diff --git a/tests/baselines/reference/constEnumPropertyAccess1.types b/tests/baselines/reference/constEnumPropertyAccess1.types index 869a31d5e1f9b..af9aacd279cab 100644 --- a/tests/baselines/reference/constEnumPropertyAccess1.types +++ b/tests/baselines/reference/constEnumPropertyAccess1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/constEnums/constEnumPropertyAccess1.ts === - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members diff --git a/tests/baselines/reference/constEnumPropertyAccess2.errors.txt b/tests/baselines/reference/constEnumPropertyAccess2.errors.txt index 9f16059ff2fc2..aa08c11c7a2ed 100644 --- a/tests/baselines/reference/constEnumPropertyAccess2.errors.txt +++ b/tests/baselines/reference/constEnumPropertyAccess2.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(14,9): error TS2475: 'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment. -tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(15,12): error TS2476: A const enum member can only be accessed using a string literal. -tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(17,1): error TS2322: Type '"string"' is not assignable to type 'G'. -tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(19,3): error TS2540: Cannot assign to 'B' because it is a constant or a read-only property. +tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(13,9): error TS2475: 'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment. +tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(14,12): error TS2476: A const enum member can only be accessed using a string literal. +tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(16,1): error TS2322: Type '"string"' is not assignable to type 'G'. +tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts(18,3): error TS2540: Cannot assign to 'B' because it is a constant or a read-only property. ==== tests/cases/conformance/constEnums/constEnumPropertyAccess2.ts (4 errors) ==== - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members diff --git a/tests/baselines/reference/constEnumPropertyAccess2.js b/tests/baselines/reference/constEnumPropertyAccess2.js index 46a1d918b94b3..f16eda4bf2dac 100644 --- a/tests/baselines/reference/constEnumPropertyAccess2.js +++ b/tests/baselines/reference/constEnumPropertyAccess2.js @@ -1,5 +1,4 @@ //// [constEnumPropertyAccess2.ts] - // constant enum declarations are completely erased in the emitted JavaScript code. // it is an error to reference a constant enum object in any other context // than a property access that selects one of the enum's members diff --git a/tests/baselines/reference/constIndexedAccess.js b/tests/baselines/reference/constIndexedAccess.js index db80441bd33d1..ea203c38e3ff8 100644 --- a/tests/baselines/reference/constIndexedAccess.js +++ b/tests/baselines/reference/constIndexedAccess.js @@ -1,5 +1,4 @@ //// [constIndexedAccess.ts] - const enum numbers { zero, one diff --git a/tests/baselines/reference/constIndexedAccess.symbols b/tests/baselines/reference/constIndexedAccess.symbols index f7ce6b78c2dd2..ef2be6368e344 100644 --- a/tests/baselines/reference/constIndexedAccess.symbols +++ b/tests/baselines/reference/constIndexedAccess.symbols @@ -1,83 +1,82 @@ === tests/cases/compiler/constIndexedAccess.ts === - const enum numbers { >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) zero, ->zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20)) +>zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 0, 20)) one ->one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) +>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 1, 9)) } interface indexAccess { ->indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 1)) +>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 3, 1)) 0: string; 1: number; } let test: indexAccess; ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 1)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 3, 1)) let s = test[0]; ->s : Symbol(s, Decl(constIndexedAccess.ts, 13, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->0 : Symbol(indexAccess[0], Decl(constIndexedAccess.ts, 6, 23)) +>s : Symbol(s, Decl(constIndexedAccess.ts, 12, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>0 : Symbol(indexAccess[0], Decl(constIndexedAccess.ts, 5, 23)) let n = test[1]; ->n : Symbol(n, Decl(constIndexedAccess.ts, 14, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->1 : Symbol(indexAccess[1], Decl(constIndexedAccess.ts, 7, 14)) +>n : Symbol(n, Decl(constIndexedAccess.ts, 13, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>1 : Symbol(indexAccess[1], Decl(constIndexedAccess.ts, 6, 14)) let s1 = test[numbers.zero]; ->s1 : Symbol(s1, Decl(constIndexedAccess.ts, 16, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->numbers.zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20)) +>s1 : Symbol(s1, Decl(constIndexedAccess.ts, 15, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>numbers.zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 0, 20)) >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) ->zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20)) +>zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 0, 20)) let n1 = test[numbers.one]; ->n1 : Symbol(n1, Decl(constIndexedAccess.ts, 17, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->numbers.one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) +>n1 : Symbol(n1, Decl(constIndexedAccess.ts, 16, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>numbers.one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 1, 9)) >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) ->one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) +>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 1, 9)) let s2 = test[numbers["zero"]]; ->s2 : Symbol(s2, Decl(constIndexedAccess.ts, 19, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) +>s2 : Symbol(s2, Decl(constIndexedAccess.ts, 18, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) ->"zero" : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20)) +>"zero" : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 0, 20)) let n2 = test[numbers["one"]]; ->n2 : Symbol(n2, Decl(constIndexedAccess.ts, 20, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) +>n2 : Symbol(n2, Decl(constIndexedAccess.ts, 19, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) >numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) ->"one" : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) +>"one" : Symbol(numbers.one, Decl(constIndexedAccess.ts, 1, 9)) enum numbersNotConst { ->numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30)) +>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 19, 30)) zero, ->zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22)) +>zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 21, 22)) one ->one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9)) +>one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 22, 9)) } let s3 = test[numbersNotConst.zero]; ->s3 : Symbol(s3, Decl(constIndexedAccess.ts, 27, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->numbersNotConst.zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22)) ->numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30)) ->zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22)) +>s3 : Symbol(s3, Decl(constIndexedAccess.ts, 26, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>numbersNotConst.zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 21, 22)) +>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 19, 30)) +>zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 21, 22)) let n3 = test[numbersNotConst.one]; ->n3 : Symbol(n3, Decl(constIndexedAccess.ts, 28, 3)) ->test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) ->numbersNotConst.one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9)) ->numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30)) ->one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9)) +>n3 : Symbol(n3, Decl(constIndexedAccess.ts, 27, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 10, 3)) +>numbersNotConst.one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 22, 9)) +>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 19, 30)) +>one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 22, 9)) diff --git a/tests/baselines/reference/constIndexedAccess.types b/tests/baselines/reference/constIndexedAccess.types index 9e08cf08f4983..e63852c1ab12f 100644 --- a/tests/baselines/reference/constIndexedAccess.types +++ b/tests/baselines/reference/constIndexedAccess.types @@ -1,5 +1,4 @@ === tests/cases/compiler/constIndexedAccess.ts === - const enum numbers { >numbers : numbers diff --git a/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt b/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt index aae5f9aac42e4..ef088d893518f 100644 --- a/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt +++ b/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts(4,1): error TS1238: Unable to resolve signature of class decorator when called as an expression. +tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts(3,1): error TS1238: Unable to resolve signature of class decorator when called as an expression. Cannot invoke an expression whose type lacks a call signature. Type 'typeof CtorDtor' has no compatible call signatures. ==== tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts (1 errors) ==== - class CtorDtor {} @CtorDtor diff --git a/tests/baselines/reference/constructableDecoratorOnClass01.js b/tests/baselines/reference/constructableDecoratorOnClass01.js index 290c36bb8306a..858d67923af76 100644 --- a/tests/baselines/reference/constructableDecoratorOnClass01.js +++ b/tests/baselines/reference/constructableDecoratorOnClass01.js @@ -1,5 +1,4 @@ //// [constructableDecoratorOnClass01.ts] - class CtorDtor {} @CtorDtor diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt index 2854e73d935d8..a572e0b34c803 100644 --- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt +++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt @@ -1,94 +1,93 @@ -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2304: Cannot find name 'module'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2503: Cannot find namespace 'module'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,19): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,35): error TS1005: ')' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,28): error TS1005: ':' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,29): error TS1005: ',' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,18): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,26): error TS2304: Cannot find name 'bfs'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(29,30): error TS1005: '=' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(32,18): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,26): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,28): error TS2304: Cannot find name 'bfs'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(36,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and '0'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(39,17): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,28): error TS2304: Cannot find name 'bfs'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,41): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,45): error TS1002: Unterminated string literal. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(42,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and '0'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(48,17): error TS2304: Cannot find name 'console'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(50,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(54,13): error TS2304: Cannot find name 'console'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(59,5): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(70,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(73,37): error TS1127: Invalid character. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(82,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,23): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(91,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,29): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(107,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(109,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(139,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(142,32): error TS1005: '{' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(144,13): error TS1005: 'try' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,24): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,30): error TS1005: '(' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,31): error TS2304: Cannot find name 'Property'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(167,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(181,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(182,13): error TS2322: Type 'boolean' is not assignable to type 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(184,13): error TS2322: Type 'boolean' is not assignable to type 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(188,13): error TS2322: Type 'true' is not assignable to type 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(192,13): error TS2322: Type 'boolean' is not assignable to type 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(206,28): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(214,16): error TS2304: Cannot find name 'bool'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(219,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(224,23): error TS2304: Cannot find name 'bool'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(228,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,14): error TS1005: '{' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,9): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,16): error TS2304: Cannot find name 'method1'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,24): error TS2304: Cannot find name 'val'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,27): error TS1005: ',' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,28): error TS2304: Cannot find name 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,36): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,9): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,16): error TS2304: Cannot find name 'method2'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,26): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(242,5): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(247,25): error TS2339: Property 'method1' does not exist on type 'B'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,9): error TS2390: Constructor implementation is missing. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,21): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,44): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,69): error TS1110: Type expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2304: Cannot find name 'module'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2503: Cannot find namespace 'module'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,19): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,35): error TS1005: ')' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,28): error TS1005: ':' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,29): error TS1005: ',' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,18): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,26): error TS2304: Cannot find name 'bfs'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,30): error TS1005: '=' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(31,18): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,26): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,28): error TS2304: Cannot find name 'bfs'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and '0'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(38,17): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,28): error TS2304: Cannot find name 'bfs'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,41): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,45): error TS1002: Unterminated string literal. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and '0'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(47,17): error TS2304: Cannot find name 'console'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(49,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(53,13): error TS2304: Cannot find name 'console'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(58,5): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(69,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(72,37): error TS1127: Invalid character. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(81,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(89,23): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(105,29): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(108,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(138,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(141,32): error TS1005: '{' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(143,13): error TS1005: 'try' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,24): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,30): error TS1005: '(' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,31): error TS2304: Cannot find name 'Property'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(166,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(180,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(181,13): error TS2322: Type 'boolean' is not assignable to type 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(183,13): error TS2322: Type 'boolean' is not assignable to type 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(187,13): error TS2322: Type 'true' is not assignable to type 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(191,13): error TS2322: Type 'boolean' is not assignable to type 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(205,28): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(213,16): error TS2304: Cannot find name 'bool'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(218,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(223,23): error TS2304: Cannot find name 'bool'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(227,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(234,14): error TS1005: '{' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,9): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,16): error TS2304: Cannot find name 'method1'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,24): error TS2304: Cannot find name 'val'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,27): error TS1005: ',' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,28): error TS2304: Cannot find name 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,36): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,9): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,16): error TS2304: Cannot find name 'method2'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,26): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(241,5): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(246,25): error TS2339: Property 'method1' does not exist on type 'B'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,9): error TS2390: Constructor implementation is missing. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,21): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,44): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,69): error TS1110: Type expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,9): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,16): error TS2304: Cannot find name 'Overloads'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,26): error TS2304: Cannot find name 'value'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,31): error TS1005: ',' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,33): error TS2304: Cannot find name 'string'. tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,9): error TS1128: Declaration or statement expected. tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,16): error TS2304: Cannot find name 'Overloads'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,26): error TS2304: Cannot find name 'value'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,31): error TS1005: ',' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,9): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,16): error TS2304: Cannot find name 'Overloads'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,27): error TS1135: Argument expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,33): error TS1005: '(' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,35): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,43): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,52): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,60): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,65): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,9): error TS2304: Cannot find name 'public'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS2304: Cannot find name 'DefaultValue'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,29): error TS2304: Cannot find name 'value'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,35): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,37): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,55): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(262,1): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,27): error TS1135: Argument expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS1005: '(' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,35): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,43): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,52): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,60): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,65): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,9): error TS2304: Cannot find name 'public'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS2304: Cannot find name 'DefaultValue'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,29): error TS2304: Cannot find name 'value'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,35): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,37): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,55): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or statement expected. ==== tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts (87 errors) ==== - declare module "fs" { export class File { constructor(filename: string); diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js index afdfa36e4a6b6..8e9dc6da68831 100644 --- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js +++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js @@ -1,5 +1,4 @@ //// [constructorWithIncompleteTypeAnnotation.ts] - declare module "fs" { export class File { constructor(filename: string); diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator01.js b/tests/baselines/reference/contextuallyTypeCommaOperator01.js index 0da3ac9100096..f8a9dbe7f8b25 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator01.js +++ b/tests/baselines/reference/contextuallyTypeCommaOperator01.js @@ -1,5 +1,4 @@ //// [contextuallyTypeCommaOperator01.ts] - let x: (a: string) => string; x = (100, a => a); diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator01.symbols b/tests/baselines/reference/contextuallyTypeCommaOperator01.symbols index c07fd28ae77e6..b3b9326ea82e4 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator01.symbols +++ b/tests/baselines/reference/contextuallyTypeCommaOperator01.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator01.ts === - let x: (a: string) => string; ->x : Symbol(x, Decl(contextuallyTypeCommaOperator01.ts, 1, 3)) ->a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 1, 8)) +>x : Symbol(x, Decl(contextuallyTypeCommaOperator01.ts, 0, 3)) +>a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 0, 8)) x = (100, a => a); ->x : Symbol(x, Decl(contextuallyTypeCommaOperator01.ts, 1, 3)) ->a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 3, 9)) ->a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 3, 9)) +>x : Symbol(x, Decl(contextuallyTypeCommaOperator01.ts, 0, 3)) +>a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 2, 9)) +>a : Symbol(a, Decl(contextuallyTypeCommaOperator01.ts, 2, 9)) diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator01.types b/tests/baselines/reference/contextuallyTypeCommaOperator01.types index 0551694921068..febf4c15bf0f1 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator01.types +++ b/tests/baselines/reference/contextuallyTypeCommaOperator01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator01.ts === - let x: (a: string) => string; >x : (a: string) => string >a : string diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator02.errors.txt b/tests/baselines/reference/contextuallyTypeCommaOperator02.errors.txt index 3214f7e5025ba..ca958a0521b33 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator02.errors.txt +++ b/tests/baselines/reference/contextuallyTypeCommaOperator02.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts(4,1): error TS2322: Type '(a: string) => number' is not assignable to type '(a: string) => string'. +tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts(3,1): error TS2322: Type '(a: string) => number' is not assignable to type '(a: string) => string'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts(4,11): error TS2322: Type 'string' is not assignable to type 'number'. ==== tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator02.ts (2 errors) ==== - let x: (a: string) => string; x = (100, a => { diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator02.js b/tests/baselines/reference/contextuallyTypeCommaOperator02.js index 0f8d67dd0ef07..1d97d7ccaae80 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator02.js +++ b/tests/baselines/reference/contextuallyTypeCommaOperator02.js @@ -1,5 +1,4 @@ //// [contextuallyTypeCommaOperator02.ts] - let x: (a: string) => string; x = (100, a => { diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator03.errors.txt b/tests/baselines/reference/contextuallyTypeCommaOperator03.errors.txt index 715b7cf70ea9b..4b14c0e174686 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator03.errors.txt +++ b/tests/baselines/reference/contextuallyTypeCommaOperator03.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator03.ts(4,6): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator03.ts(3,6): error TS7006: Parameter 'a' implicitly has an 'any' type. ==== tests/cases/conformance/types/contextualTypes/commaOperator/contextuallyTypeCommaOperator03.ts (1 errors) ==== - let x: (a: string) => string; x = (a => a, b => b); diff --git a/tests/baselines/reference/contextuallyTypeCommaOperator03.js b/tests/baselines/reference/contextuallyTypeCommaOperator03.js index c4754f28c41f8..52ed4d6d363c6 100644 --- a/tests/baselines/reference/contextuallyTypeCommaOperator03.js +++ b/tests/baselines/reference/contextuallyTypeCommaOperator03.js @@ -1,5 +1,4 @@ //// [contextuallyTypeCommaOperator03.ts] - let x: (a: string) => string; x = (a => a, b => b); diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd01.js b/tests/baselines/reference/contextuallyTypeLogicalAnd01.js index b8b1f0d1e005b..35b509f1192f3 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd01.js +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd01.js @@ -1,5 +1,4 @@ //// [contextuallyTypeLogicalAnd01.ts] - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd01.symbols b/tests/baselines/reference/contextuallyTypeLogicalAnd01.symbols index 4d69b43e66949..a16ba5cc3927f 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd01.symbols +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd01.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd01.ts === - let x: (a: string) => string; ->x : Symbol(x, Decl(contextuallyTypeLogicalAnd01.ts, 1, 3)) ->a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 1, 8)) +>x : Symbol(x, Decl(contextuallyTypeLogicalAnd01.ts, 0, 3)) +>a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 0, 8)) let y = true; ->y : Symbol(y, Decl(contextuallyTypeLogicalAnd01.ts, 2, 3)) +>y : Symbol(y, Decl(contextuallyTypeLogicalAnd01.ts, 1, 3)) x = y && (a => a); ->x : Symbol(x, Decl(contextuallyTypeLogicalAnd01.ts, 1, 3)) ->y : Symbol(y, Decl(contextuallyTypeLogicalAnd01.ts, 2, 3)) ->a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 4, 10)) ->a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 4, 10)) +>x : Symbol(x, Decl(contextuallyTypeLogicalAnd01.ts, 0, 3)) +>y : Symbol(y, Decl(contextuallyTypeLogicalAnd01.ts, 1, 3)) +>a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 3, 10)) +>a : Symbol(a, Decl(contextuallyTypeLogicalAnd01.ts, 3, 10)) diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd01.types b/tests/baselines/reference/contextuallyTypeLogicalAnd01.types index e55e1e4b511ef..4ab8849b1332d 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd01.types +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd01.ts === - let x: (a: string) => string; >x : (a: string) => string >a : string diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd02.errors.txt b/tests/baselines/reference/contextuallyTypeLogicalAnd02.errors.txt index 7452d333d8832..1d6637d8446ac 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd02.errors.txt +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd02.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts(5,1): error TS2322: Type '(a: string) => number' is not assignable to type '(a: string) => string'. +tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts(4,1): error TS2322: Type '(a: string) => number' is not assignable to type '(a: string) => string'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts(6,11): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. ==== tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd02.ts (2 errors) ==== - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd02.js b/tests/baselines/reference/contextuallyTypeLogicalAnd02.js index 6dc1fa5b26a1e..11ec0aa03a805 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd02.js +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd02.js @@ -1,5 +1,4 @@ //// [contextuallyTypeLogicalAnd02.ts] - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd03.errors.txt b/tests/baselines/reference/contextuallyTypeLogicalAnd03.errors.txt index 1430be0042724..e525663320978 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd03.errors.txt +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd03.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd03.ts(5,6): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd03.ts(4,6): error TS7006: Parameter 'a' implicitly has an 'any' type. ==== tests/cases/conformance/types/contextualTypes/logicalAnd/contextuallyTypeLogicalAnd03.ts (1 errors) ==== - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypeLogicalAnd03.js b/tests/baselines/reference/contextuallyTypeLogicalAnd03.js index cbf1b3a319ad6..67bcb052644f9 100644 --- a/tests/baselines/reference/contextuallyTypeLogicalAnd03.js +++ b/tests/baselines/reference/contextuallyTypeLogicalAnd03.js @@ -1,5 +1,4 @@ //// [contextuallyTypeLogicalAnd03.ts] - let x: (a: string) => string; let y = true; diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.errors.txt b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.errors.txt index dab85baf2cfc4..1fef4e6126894 100644 --- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.errors.txt +++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(17,24): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(20,24): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(28,27): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(31,27): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(39,36): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(42,36): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(16,24): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(19,24): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(27,27): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(30,27): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(38,36): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts(41,36): error TS7006: Parameter 'arg' implicitly has an 'any' type. ==== tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration01.ts (6 errors) ==== - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.js b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.js index a6eaa0480935f..5b33cc5c7993d 100644 --- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.js +++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.js @@ -1,5 +1,4 @@ //// [contextuallyTypedClassExpressionMethodDeclaration01.ts] - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.errors.txt b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.errors.txt index ae6dfee486601..207d960ac3c39 100644 --- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.errors.txt +++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(21,17): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(24,17): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(32,20): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(35,20): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(43,29): error TS7006: Parameter 'arg' implicitly has an 'any' type. -tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(46,29): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(20,17): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(23,17): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(31,20): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(34,20): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(42,29): error TS7006: Parameter 'arg' implicitly has an 'any' type. +tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts(45,29): error TS7006: Parameter 'arg' implicitly has an 'any' type. ==== tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedClassExpressionMethodDeclaration02.ts (6 errors) ==== - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.js b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.js index ecd6e3c7dde3c..4f1305053826a 100644 --- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.js +++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.js @@ -1,5 +1,4 @@ //// [contextuallyTypedClassExpressionMethodDeclaration02.ts] - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.js b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.js index 373854114d546..ad84355595cea 100644 --- a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.js +++ b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.js @@ -1,5 +1,4 @@ //// [contextuallyTypedObjectLiteralMethodDeclaration01.ts] - interface A { numProp: number; } diff --git a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.symbols b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.symbols index c240af42b910b..156eddefd9371 100644 --- a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.symbols +++ b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.symbols @@ -1,110 +1,109 @@ === tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedObjectLiteralMethodDeclaration01.ts === - interface A { >A : Symbol(A, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 0)) numProp: number; ->numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) +>numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) } interface B { ->B : Symbol(B, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 3, 1)) +>B : Symbol(B, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 2, 1)) strProp: string; ->strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) +>strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) } interface Foo { ->Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 7, 1)) +>Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 6, 1)) method1(arg: A): void; ->method1 : Symbol(Foo.method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 9, 15)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 10, 12)) +>method1 : Symbol(Foo.method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 8, 15)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 9, 12)) >A : Symbol(A, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 0)) method2(arg: B): void; ->method2 : Symbol(Foo.method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 10, 26)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 11, 12)) ->B : Symbol(B, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 3, 1)) +>method2 : Symbol(Foo.method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 9, 26)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 10, 12)) +>B : Symbol(B, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 2, 1)) } function getFoo1(): Foo { ->getFoo1 : Symbol(getFoo1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 12, 1)) ->Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 7, 1)) +>getFoo1 : Symbol(getFoo1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 11, 1)) +>Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 6, 1)) return { method1(arg) { ->method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 15, 12)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 16, 16)) +>method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 14, 12)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 15, 16)) arg.numProp = 10; ->arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 16, 16)) ->numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) +>arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 15, 16)) +>numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) }, method2(arg) { ->method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 18, 10)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 19, 16)) +>method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 17, 10)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 18, 16)) arg.strProp = "hello"; ->arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 19, 16)) ->strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) +>arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 18, 16)) +>strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) } } } function getFoo2(): Foo { ->getFoo2 : Symbol(getFoo2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 23, 1)) ->Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 7, 1)) +>getFoo2 : Symbol(getFoo2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 22, 1)) +>Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 6, 1)) return { method1: (arg) => { ->method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 26, 12)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 27, 18)) +>method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 25, 12)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 26, 18)) arg.numProp = 10; ->arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 27, 18)) ->numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) +>arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 26, 18)) +>numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) }, method2: (arg) => { ->method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 29, 10)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 30, 18)) +>method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 28, 10)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 29, 18)) arg.strProp = "hello"; ->arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 30, 18)) ->strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) +>arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 29, 18)) +>strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) } } } function getFoo3(): Foo { ->getFoo3 : Symbol(getFoo3, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 34, 1)) ->Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 7, 1)) +>getFoo3 : Symbol(getFoo3, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 33, 1)) +>Foo : Symbol(Foo, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 6, 1)) return { method1: function (arg) { ->method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 37, 12)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 38, 27)) +>method1 : Symbol(method1, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 36, 12)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 37, 27)) arg.numProp = 10; ->arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 38, 27)) ->numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 1, 13)) +>arg.numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 37, 27)) +>numProp : Symbol(A.numProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 0, 13)) }, method2: function (arg) { ->method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 40, 10)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 41, 27)) +>method2 : Symbol(method2, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 39, 10)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 40, 27)) arg.strProp = "hello"; ->arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) ->arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 41, 27)) ->strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 5, 14)) +>arg.strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) +>arg : Symbol(arg, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 40, 27)) +>strProp : Symbol(B.strProp, Decl(contextuallyTypedObjectLiteralMethodDeclaration01.ts, 4, 14)) } } } diff --git a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.types b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.types index 5335cc4f81f45..abf1a65158c90 100644 --- a/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.types +++ b/tests/baselines/reference/contextuallyTypedObjectLiteralMethodDeclaration01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedObjectLiteralMethodDeclaration01.ts === - interface A { >A : A diff --git a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.errors.txt b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.errors.txt index 47d0b8c839ada..4b74bb357ea98 100644 --- a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.errors.txt +++ b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx(16,15): error TS2322: Type '{ foo: "f"; }' is not assignable to type '{ foo: "A" | "B" | "C"; }'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx(15,15): error TS2322: Type '{ foo: "f"; }' is not assignable to type '{ foo: "A" | "B" | "C"; }'. Types of property 'foo' are incompatible. Type '"f"' is not assignable to type '"A" | "B" | "C"'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx(17,15): error TS2322: Type '{ foo: "f"; }' is not assignable to type '{ foo: "A" | "B" | "C"; }'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx(16,15): error TS2322: Type '{ foo: "f"; }' is not assignable to type '{ foo: "A" | "B" | "C"; }'. Types of property 'foo' are incompatible. Type '"f"' is not assignable to type '"A" | "B" | "C"'. ==== tests/cases/conformance/types/contextualTypes/jsxAttributes/contextuallyTypedStringLiteralsInJsxAttributes01.tsx (2 errors) ==== - namespace JSX { export interface IntrinsicElements { span: {}; diff --git a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.js b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.js index d1b2ebf5ae544..7913e1ff5d005 100644 --- a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.js +++ b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.js @@ -1,5 +1,4 @@ //// [contextuallyTypedStringLiteralsInJsxAttributes01.tsx] - namespace JSX { export interface IntrinsicElements { span: {}; diff --git a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt index 0ef067e5bbca5..28c550ccda1d6 100644 --- a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt +++ b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt @@ -1,19 +1,18 @@ -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(28,24): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(27,24): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(29,24): error TS2322: Type '{ onClick: (k: "left" | "right") => void; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(28,24): error TS2322: Type '{ onClick: (k: "left" | "right") => void; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'onClick' does not exist on type 'IntrinsicAttributes & LinkProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(30,24): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(29,24): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(31,24): error TS2322: Type '{ goTo: "home"; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(30,24): error TS2322: Type '{ goTo: "home"; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(34,25): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(33,25): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & ButtonProps'. -tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(37,25): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. +tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(36,25): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'. Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'. ==== tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx (6 errors) ==== - import React = require('react') export interface ClickableProps { diff --git a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.js b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.js index 6f195cabebdfa..9eb261b9d7a23 100644 --- a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.js +++ b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react') export interface ClickableProps { diff --git a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt b/tests/baselines/reference/continueNotInIterationStatement4.errors.txt index dec899c7218f7..1c80f7057b878 100644 --- a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt +++ b/tests/baselines/reference/continueNotInIterationStatement4.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/continueNotInIterationStatement4.ts(5,5): error TS1107: Jump target cannot cross function boundary. +tests/cases/compiler/continueNotInIterationStatement4.ts(4,5): error TS1107: Jump target cannot cross function boundary. ==== tests/cases/compiler/continueNotInIterationStatement4.ts (1 errors) ==== - TWO: while (true){ var x = () => { diff --git a/tests/baselines/reference/continueNotInIterationStatement4.js b/tests/baselines/reference/continueNotInIterationStatement4.js index 50261be23b188..f3f52ecb48ca3 100644 --- a/tests/baselines/reference/continueNotInIterationStatement4.js +++ b/tests/baselines/reference/continueNotInIterationStatement4.js @@ -1,5 +1,4 @@ //// [continueNotInIterationStatement4.ts] - TWO: while (true){ var x = () => { diff --git a/tests/baselines/reference/continueTarget3.js b/tests/baselines/reference/continueTarget3.js index 70c2d2590e570..052b7b593c31d 100644 --- a/tests/baselines/reference/continueTarget3.js +++ b/tests/baselines/reference/continueTarget3.js @@ -1,5 +1,4 @@ //// [continueTarget3.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/continueTarget3.symbols b/tests/baselines/reference/continueTarget3.symbols index a5decfe16d102..a1b930f2f5ac2 100644 --- a/tests/baselines/reference/continueTarget3.symbols +++ b/tests/baselines/reference/continueTarget3.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/continueTarget3.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target1; diff --git a/tests/baselines/reference/continueTarget3.types b/tests/baselines/reference/continueTarget3.types index 502c406b05f73..5d45c50dc673b 100644 --- a/tests/baselines/reference/continueTarget3.types +++ b/tests/baselines/reference/continueTarget3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/continueTarget3.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/continueTarget4.js b/tests/baselines/reference/continueTarget4.js index 23c20a03260f9..0f6211f9202cb 100644 --- a/tests/baselines/reference/continueTarget4.js +++ b/tests/baselines/reference/continueTarget4.js @@ -1,5 +1,4 @@ //// [continueTarget4.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/continueTarget4.symbols b/tests/baselines/reference/continueTarget4.symbols index fc69a881a60a3..ea1989a3e4d22 100644 --- a/tests/baselines/reference/continueTarget4.symbols +++ b/tests/baselines/reference/continueTarget4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/continueTarget4.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target2; diff --git a/tests/baselines/reference/continueTarget4.types b/tests/baselines/reference/continueTarget4.types index e07208ccc10fe..44160045532a9 100644 --- a/tests/baselines/reference/continueTarget4.types +++ b/tests/baselines/reference/continueTarget4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/continueTarget4.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/continueTarget5.errors.txt b/tests/baselines/reference/continueTarget5.errors.txt index 854f57017b620..401c5874ee043 100644 --- a/tests/baselines/reference/continueTarget5.errors.txt +++ b/tests/baselines/reference/continueTarget5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/continueTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary. +tests/cases/compiler/continueTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary. ==== tests/cases/compiler/continueTarget5.ts (1 errors) ==== - target: while (true) { function f() { diff --git a/tests/baselines/reference/continueTarget5.js b/tests/baselines/reference/continueTarget5.js index 030a1c2589c59..5bf309d2690e8 100644 --- a/tests/baselines/reference/continueTarget5.js +++ b/tests/baselines/reference/continueTarget5.js @@ -1,5 +1,4 @@ //// [continueTarget5.ts] - target: while (true) { function f() { diff --git a/tests/baselines/reference/controlFlowArrayErrors.errors.txt b/tests/baselines/reference/controlFlowArrayErrors.errors.txt index 2ef009dc0e115..403cafacf5d23 100644 --- a/tests/baselines/reference/controlFlowArrayErrors.errors.txt +++ b/tests/baselines/reference/controlFlowArrayErrors.errors.txt @@ -1,19 +1,18 @@ -tests/cases/compiler/controlFlowArrayErrors.ts(5,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowArrayErrors.ts(6,13): error TS7005: Variable 'x' implicitly has an 'any[]' type. -tests/cases/compiler/controlFlowArrayErrors.ts(12,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowArrayErrors.ts(14,13): error TS7005: Variable 'x' implicitly has an 'any[]' type. -tests/cases/compiler/controlFlowArrayErrors.ts(20,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowArrayErrors.ts(23,9): error TS7005: Variable 'x' implicitly has an 'any[]' type. -tests/cases/compiler/controlFlowArrayErrors.ts(30,12): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'. -tests/cases/compiler/controlFlowArrayErrors.ts(35,12): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'. -tests/cases/compiler/controlFlowArrayErrors.ts(49,5): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type '((...items: (string | number)[]) => number) | ((...items: boolean[]) => number)' has no compatible call signatures. -tests/cases/compiler/controlFlowArrayErrors.ts(57,12): error TS2345: Argument of type '"hello"' is not assignable to parameter of type 'number'. -tests/cases/compiler/controlFlowArrayErrors.ts(61,11): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowArrayErrors.ts(64,9): error TS7005: Variable 'x' implicitly has an 'any[]' type. +tests/cases/compiler/controlFlowArrayErrors.ts(4,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowArrayErrors.ts(5,13): error TS7005: Variable 'x' implicitly has an 'any[]' type. +tests/cases/compiler/controlFlowArrayErrors.ts(11,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowArrayErrors.ts(13,13): error TS7005: Variable 'x' implicitly has an 'any[]' type. +tests/cases/compiler/controlFlowArrayErrors.ts(19,9): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowArrayErrors.ts(22,9): error TS7005: Variable 'x' implicitly has an 'any[]' type. +tests/cases/compiler/controlFlowArrayErrors.ts(29,12): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'. +tests/cases/compiler/controlFlowArrayErrors.ts(34,12): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'. +tests/cases/compiler/controlFlowArrayErrors.ts(48,5): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type '((...items: (string | number)[]) => number) | ((...items: boolean[]) => number)' has no compatible call signatures. +tests/cases/compiler/controlFlowArrayErrors.ts(56,12): error TS2345: Argument of type '"hello"' is not assignable to parameter of type 'number'. +tests/cases/compiler/controlFlowArrayErrors.ts(60,11): error TS7034: Variable 'x' implicitly has type 'any[]' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowArrayErrors.ts(63,9): error TS7005: Variable 'x' implicitly has an 'any[]' type. ==== tests/cases/compiler/controlFlowArrayErrors.ts (12 errors) ==== - declare function cond(): boolean; function f1() { diff --git a/tests/baselines/reference/controlFlowArrayErrors.js b/tests/baselines/reference/controlFlowArrayErrors.js index 59995eb309475..d1a76b80ebf3e 100644 --- a/tests/baselines/reference/controlFlowArrayErrors.js +++ b/tests/baselines/reference/controlFlowArrayErrors.js @@ -1,5 +1,4 @@ //// [controlFlowArrayErrors.ts] - declare function cond(): boolean; function f1() { diff --git a/tests/baselines/reference/controlFlowArrays.js b/tests/baselines/reference/controlFlowArrays.js index 3f1195994952b..134216b2eeabc 100644 --- a/tests/baselines/reference/controlFlowArrays.js +++ b/tests/baselines/reference/controlFlowArrays.js @@ -1,5 +1,4 @@ //// [controlFlowArrays.ts] - declare function cond(): boolean; function f1() { diff --git a/tests/baselines/reference/controlFlowArrays.symbols b/tests/baselines/reference/controlFlowArrays.symbols index 184a813a05fd2..ad6ee0e9f8017 100644 --- a/tests/baselines/reference/controlFlowArrays.symbols +++ b/tests/baselines/reference/controlFlowArrays.symbols @@ -1,379 +1,378 @@ === tests/cases/compiler/controlFlowArrays.ts === - declare function cond(): boolean; >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) function f1() { ->f1 : Symbol(f1, Decl(controlFlowArrays.ts, 1, 33)) +>f1 : Symbol(f1, Decl(controlFlowArrays.ts, 0, 33)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) x[0] = 5; ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) x[1] = "hello"; ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) x[2] = true; ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 3, 7)) } function f2() { ->f2 : Symbol(f2, Decl(controlFlowArrays.ts, 9, 1)) +>f2 : Symbol(f2, Decl(controlFlowArrays.ts, 8, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 12, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 11, 7)) } function f3() { ->f3 : Symbol(f3, Decl(controlFlowArrays.ts, 17, 1)) +>f3 : Symbol(f3, Decl(controlFlowArrays.ts, 16, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 20, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 19, 7)) x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 20, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 19, 7)) x.push(5, "hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 20, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 19, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 20, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 19, 7)) } function f4() { ->f4 : Symbol(f4, Decl(controlFlowArrays.ts, 24, 1)) +>f4 : Symbol(f4, Decl(controlFlowArrays.ts, 23, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 26, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 26, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } else { x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 26, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; // (string | number)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 26, 7)) } function f5() { ->f5 : Symbol(f5, Decl(controlFlowArrays.ts, 35, 1)) +>f5 : Symbol(f5, Decl(controlFlowArrays.ts, 34, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } else { x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; // (string | number)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 38, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 37, 7)) } function f6() { ->f6 : Symbol(f6, Decl(controlFlowArrays.ts, 48, 1)) +>f6 : Symbol(f6, Decl(controlFlowArrays.ts, 47, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x = 5; ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) } else { x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; // number | string[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 51, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 50, 7)) } function f7() { ->f7 : Symbol(f7, Decl(controlFlowArrays.ts, 60, 1)) +>f7 : Symbol(f7, Decl(controlFlowArrays.ts, 59, 1)) let x = null; ->x : Symbol(x, Decl(controlFlowArrays.ts, 63, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 62, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 63, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 62, 7)) while (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 63, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 62, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } } return x; // string[] | null ->x : Symbol(x, Decl(controlFlowArrays.ts, 63, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 62, 7)) } function f8() { ->f8 : Symbol(f8, Decl(controlFlowArrays.ts, 71, 1)) +>f8 : Symbol(f8, Decl(controlFlowArrays.ts, 70, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) if (cond()) return x; // number[] >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) if (cond()) return x; // (string | number)[] >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 74, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 73, 7)) } function f9() { ->f9 : Symbol(f9, Decl(controlFlowArrays.ts, 81, 1)) +>f9 : Symbol(f9, Decl(controlFlowArrays.ts, 80, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // number[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) } else { x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // string[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 84, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 83, 7)) } } function f10() { ->f10 : Symbol(f10, Decl(controlFlowArrays.ts, 93, 1)) +>f10 : Symbol(f10, Decl(controlFlowArrays.ts, 92, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) if (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x; // boolean[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) } else { x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x; // number[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) while (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } x; // (string | number)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) } x.push(99); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 96, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 95, 7)) } function f11() { ->f11 : Symbol(f11, Decl(controlFlowArrays.ts, 111, 1)) +>f11 : Symbol(f11, Decl(controlFlowArrays.ts, 110, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 114, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 113, 7)) if (x.length === 0) { // x.length ok on implicit any[] >x.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 114, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 113, 7)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 114, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 113, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 114, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 113, 7)) } function f12() { ->f12 : Symbol(f12, Decl(controlFlowArrays.ts, 119, 1)) +>f12 : Symbol(f12, Decl(controlFlowArrays.ts, 118, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) if (x.length === 0) { // x.length ok on implicit any[] >x.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 122, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 121, 7)) } function f13() { ->f13 : Symbol(f13, Decl(controlFlowArrays.ts, 128, 1)) +>f13 : Symbol(f13, Decl(controlFlowArrays.ts, 127, 1)) var x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 131, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 130, 7)) } function f14() { ->f14 : Symbol(f14, Decl(controlFlowArrays.ts, 136, 1)) +>f14 : Symbol(f14, Decl(controlFlowArrays.ts, 135, 1)) const x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push(true); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 139, 9)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 138, 9)) } function f15() { ->f15 : Symbol(f15, Decl(controlFlowArrays.ts, 144, 1)) +>f15 : Symbol(f15, Decl(controlFlowArrays.ts, 143, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 147, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 146, 7)) while (cond()) { >cond : Symbol(cond, Decl(controlFlowArrays.ts, 0, 0)) @@ -383,88 +382,88 @@ function f15() { x.push("hello"); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 147, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 146, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } return x; // string[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 147, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 146, 7)) } function f16() { ->f16 : Symbol(f16, Decl(controlFlowArrays.ts, 153, 1)) +>f16 : Symbol(f16, Decl(controlFlowArrays.ts, 152, 1)) let x; ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) let y; ->y : Symbol(y, Decl(controlFlowArrays.ts, 157, 7)) +>y : Symbol(y, Decl(controlFlowArrays.ts, 156, 7)) (x = [], x).push(5); >(x = [], x).push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) (x.push("hello"), x).push(true); >(x.push("hello"), x).push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ((x))[3] = { a: 1 }; ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) ->a : Symbol(a, Decl(controlFlowArrays.ts, 160, 16)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) +>a : Symbol(a, Decl(controlFlowArrays.ts, 159, 16)) return x; // (string | number | boolean | { a: number })[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 156, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7)) } function f17() { ->f17 : Symbol(f17, Decl(controlFlowArrays.ts, 162, 1)) +>f17 : Symbol(f17, Decl(controlFlowArrays.ts, 161, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) x.unshift(5); >x.unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) >unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) x.unshift("hello"); >x.unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) >unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) x.unshift(true); >x.unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) >unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 165, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 164, 7)) } function f18() { ->f18 : Symbol(f18, Decl(controlFlowArrays.ts, 170, 1)) +>f18 : Symbol(f18, Decl(controlFlowArrays.ts, 169, 1)) let x = []; ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) x.push(5); >x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.unshift("hello"); >x.unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) >unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --)) x[2] = true; ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) return x; // (string | number | boolean)[] ->x : Symbol(x, Decl(controlFlowArrays.ts, 173, 7)) +>x : Symbol(x, Decl(controlFlowArrays.ts, 172, 7)) } diff --git a/tests/baselines/reference/controlFlowArrays.types b/tests/baselines/reference/controlFlowArrays.types index 2a27bbf10ded4..6dbddbda075fc 100644 --- a/tests/baselines/reference/controlFlowArrays.types +++ b/tests/baselines/reference/controlFlowArrays.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowArrays.ts === - declare function cond(): boolean; >cond : () => boolean diff --git a/tests/baselines/reference/controlFlowCaching.js b/tests/baselines/reference/controlFlowCaching.js index fc102b8e823b1..c8b7cb5cc2cb6 100644 --- a/tests/baselines/reference/controlFlowCaching.js +++ b/tests/baselines/reference/controlFlowCaching.js @@ -1,5 +1,4 @@ //// [controlFlowCaching.ts] - // Repro for #8401 function f(dim, offsets, arr, acommon, centerAnchorLimit, g, has, lin) { diff --git a/tests/baselines/reference/controlFlowCaching.symbols b/tests/baselines/reference/controlFlowCaching.symbols index 74534ce75a1b0..186c770b0ae44 100644 --- a/tests/baselines/reference/controlFlowCaching.symbols +++ b/tests/baselines/reference/controlFlowCaching.symbols @@ -1,279 +1,278 @@ === tests/cases/compiler/controlFlowCaching.ts === - // Repro for #8401 function f(dim, offsets, arr, acommon, centerAnchorLimit, g, has, lin) { >f : Symbol(f, Decl(controlFlowCaching.ts, 0, 0)) ->dim : Symbol(dim, Decl(controlFlowCaching.ts, 3, 11)) ->offsets : Symbol(offsets, Decl(controlFlowCaching.ts, 3, 15)) ->arr : Symbol(arr, Decl(controlFlowCaching.ts, 3, 24)) ->acommon : Symbol(acommon, Decl(controlFlowCaching.ts, 3, 29)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->has : Symbol(has, Decl(controlFlowCaching.ts, 3, 60)) ->lin : Symbol(lin, Decl(controlFlowCaching.ts, 3, 65)) +>dim : Symbol(dim, Decl(controlFlowCaching.ts, 2, 11)) +>offsets : Symbol(offsets, Decl(controlFlowCaching.ts, 2, 15)) +>arr : Symbol(arr, Decl(controlFlowCaching.ts, 2, 24)) +>acommon : Symbol(acommon, Decl(controlFlowCaching.ts, 2, 29)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>has : Symbol(has, Decl(controlFlowCaching.ts, 2, 60)) +>lin : Symbol(lin, Decl(controlFlowCaching.ts, 2, 65)) var isRtl = this._isRtl(); // chart mirroring ->isRtl : Symbol(isRtl, Decl(controlFlowCaching.ts, 4, 7)) +>isRtl : Symbol(isRtl, Decl(controlFlowCaching.ts, 3, 7)) // prepare variable var o = this.opt, ta = this.chart.theme.axis, position = o.position, ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->position : Symbol(position, Decl(controlFlowCaching.ts, 6, 49)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>position : Symbol(position, Decl(controlFlowCaching.ts, 5, 49)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) leftBottom = position !== "rightOrTop", rotation = o.rotation % 360, ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->position : Symbol(position, Decl(controlFlowCaching.ts, 6, 49)) ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>position : Symbol(position, Decl(controlFlowCaching.ts, 5, 49)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) start, stop, titlePos, titleRotation = 0, titleOffset, axisVector, tickVector, anchorOffset, labelOffset, labelAlign, ->start : Symbol(start, Decl(controlFlowCaching.ts, 7, 76)) ->stop : Symbol(stop, Decl(controlFlowCaching.ts, 8, 14)) ->titlePos : Symbol(titlePos, Decl(controlFlowCaching.ts, 8, 20)) ->titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 8, 30)) ->titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 8, 49)) ->axisVector : Symbol(axisVector, Decl(controlFlowCaching.ts, 8, 62)) ->tickVector : Symbol(tickVector, Decl(controlFlowCaching.ts, 8, 74)) ->anchorOffset : Symbol(anchorOffset, Decl(controlFlowCaching.ts, 8, 86)) ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 8, 113)) +>start : Symbol(start, Decl(controlFlowCaching.ts, 6, 76)) +>stop : Symbol(stop, Decl(controlFlowCaching.ts, 7, 14)) +>titlePos : Symbol(titlePos, Decl(controlFlowCaching.ts, 7, 20)) +>titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 7, 30)) +>titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 7, 49)) +>axisVector : Symbol(axisVector, Decl(controlFlowCaching.ts, 7, 62)) +>tickVector : Symbol(tickVector, Decl(controlFlowCaching.ts, 7, 74)) +>anchorOffset : Symbol(anchorOffset, Decl(controlFlowCaching.ts, 7, 86)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 7, 113)) labelGap = this.chart.theme.axis.tick.labelGap, ->labelGap : Symbol(labelGap, Decl(controlFlowCaching.ts, 8, 125)) +>labelGap : Symbol(labelGap, Decl(controlFlowCaching.ts, 7, 125)) taFont = o.font || (ta.majorTick && ta.majorTick.font) || (ta.tick && ta.tick.font), ->taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 9, 55)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 8, 55)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taTitleFont = o.titleFont || (ta.title && ta.title.font), ->taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 10, 92)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 9, 92)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taFontColor = o.fontColor || (ta.majorTick && ta.majorTick.fontColor) || (ta.tick && ta.tick.fontColor) || "black", ->taFontColor : Symbol(taFontColor, Decl(controlFlowCaching.ts, 11, 65)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taFontColor : Symbol(taFontColor, Decl(controlFlowCaching.ts, 10, 65)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taTitleFontColor = o.titleFontColor || (ta.title && ta.title.fontColor) || "black", ->taTitleFontColor : Symbol(taTitleFontColor, Decl(controlFlowCaching.ts, 12, 123)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taTitleFontColor : Symbol(taTitleFontColor, Decl(controlFlowCaching.ts, 11, 123)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taTitleGap = (o.titleGap == 0) ? 0 : o.titleGap || (ta.title && ta.title.gap) || 15, ->taTitleGap : Symbol(taTitleGap, Decl(controlFlowCaching.ts, 13, 91)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taTitleGap : Symbol(taTitleGap, Decl(controlFlowCaching.ts, 12, 91)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taTitleOrientation = o.titleOrientation || (ta.title && ta.title.orientation) || "axis", ->taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 14, 92)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 13, 92)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) taMajorTick = this.chart.theme.getTick("major", o), ->taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 15, 96)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 14, 96)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) taMinorTick = this.chart.theme.getTick("minor", o), ->taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 16, 59)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 15, 59)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) taMicroTick = this.chart.theme.getTick("micro", o), ->taMicroTick : Symbol(taMicroTick, Decl(controlFlowCaching.ts, 17, 59)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) +>taMicroTick : Symbol(taMicroTick, Decl(controlFlowCaching.ts, 16, 59)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) taStroke = "stroke" in o ? o.stroke : ta.stroke, ->taStroke : Symbol(taStroke, Decl(controlFlowCaching.ts, 18, 59)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->o : Symbol(o, Decl(controlFlowCaching.ts, 6, 7)) ->ta : Symbol(ta, Decl(controlFlowCaching.ts, 6, 21)) +>taStroke : Symbol(taStroke, Decl(controlFlowCaching.ts, 17, 59)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>o : Symbol(o, Decl(controlFlowCaching.ts, 5, 7)) +>ta : Symbol(ta, Decl(controlFlowCaching.ts, 5, 21)) size = taFont ? g.normalizedLength(g.splitFontString(taFont).size) : 0, ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) ->taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 9, 55)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 9, 55)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) +>taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 8, 55)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>taFont : Symbol(taFont, Decl(controlFlowCaching.ts, 8, 55)) cosr = Math.abs(Math.cos(rotation * Math.PI / 180)), ->cosr : Symbol(cosr, Decl(controlFlowCaching.ts, 21, 79)) +>cosr : Symbol(cosr, Decl(controlFlowCaching.ts, 20, 79)) >Math.abs : Symbol(Math.abs, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >abs : Symbol(Math.abs, Decl(lib.d.ts, --, --)) >Math.cos : Symbol(Math.cos, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >cos : Symbol(Math.cos, Decl(lib.d.ts, --, --)) ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) >Math.PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) sinr = Math.abs(Math.sin(rotation * Math.PI / 180)), ->sinr : Symbol(sinr, Decl(controlFlowCaching.ts, 22, 60)) +>sinr : Symbol(sinr, Decl(controlFlowCaching.ts, 21, 60)) >Math.abs : Symbol(Math.abs, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >abs : Symbol(Math.abs, Decl(lib.d.ts, --, --)) >Math.sin : Symbol(Math.sin, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >sin : Symbol(Math.sin, Decl(lib.d.ts, --, --)) ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) >Math.PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) tsize = taTitleFont ? g.normalizedLength(g.splitFontString(taTitleFont).size) : 0; ->tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 23, 60)) ->taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 10, 92)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->g : Symbol(g, Decl(controlFlowCaching.ts, 3, 57)) ->taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 10, 92)) +>tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 22, 60)) +>taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 9, 92)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>g : Symbol(g, Decl(controlFlowCaching.ts, 2, 57)) +>taTitleFont : Symbol(taTitleFont, Decl(controlFlowCaching.ts, 9, 92)) if (rotation < 0) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) rotation += 360; ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) } var cachedLabelW = this._getMaxLabelSize(); ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) cachedLabelW = cachedLabelW && cachedLabelW.majLabelW; ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) titleOffset = size * cosr + (cachedLabelW || 0) * sinr + labelGap + Math.max(taMajorTick.length > 0 ? taMajorTick.length : 0, ->titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 8, 49)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) ->cosr : Symbol(cosr, Decl(controlFlowCaching.ts, 21, 79)) ->cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 28, 7)) ->sinr : Symbol(sinr, Decl(controlFlowCaching.ts, 22, 60)) ->labelGap : Symbol(labelGap, Decl(controlFlowCaching.ts, 8, 125)) +>titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 7, 49)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) +>cosr : Symbol(cosr, Decl(controlFlowCaching.ts, 20, 79)) +>cachedLabelW : Symbol(cachedLabelW, Decl(controlFlowCaching.ts, 27, 7)) +>sinr : Symbol(sinr, Decl(controlFlowCaching.ts, 21, 60)) +>labelGap : Symbol(labelGap, Decl(controlFlowCaching.ts, 7, 125)) >Math.max : Symbol(Math.max, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >max : Symbol(Math.max, Decl(lib.d.ts, --, --)) ->taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 15, 96)) ->taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 15, 96)) +>taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 14, 96)) +>taMajorTick : Symbol(taMajorTick, Decl(controlFlowCaching.ts, 14, 96)) taMinorTick.length > 0 ? taMinorTick.length : 0) + ->taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 16, 59)) ->taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 16, 59)) +>taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 15, 59)) +>taMinorTick : Symbol(taMinorTick, Decl(controlFlowCaching.ts, 15, 59)) tsize + taTitleGap; ->tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 23, 60)) ->taTitleGap : Symbol(taTitleGap, Decl(controlFlowCaching.ts, 13, 91)) +>tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 22, 60)) +>taTitleGap : Symbol(taTitleGap, Decl(controlFlowCaching.ts, 12, 91)) axisVector = { x: isRtl ? -1 : 1, y: 0 }; // chart mirroring ->axisVector : Symbol(axisVector, Decl(controlFlowCaching.ts, 8, 62)) ->x : Symbol(x, Decl(controlFlowCaching.ts, 33, 18)) ->isRtl : Symbol(isRtl, Decl(controlFlowCaching.ts, 4, 7)) ->y : Symbol(y, Decl(controlFlowCaching.ts, 33, 37)) +>axisVector : Symbol(axisVector, Decl(controlFlowCaching.ts, 7, 62)) +>x : Symbol(x, Decl(controlFlowCaching.ts, 32, 18)) +>isRtl : Symbol(isRtl, Decl(controlFlowCaching.ts, 3, 7)) +>y : Symbol(y, Decl(controlFlowCaching.ts, 32, 37)) switch (rotation) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) default: if (rotation < (90 - centerAnchorLimit)) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) labelOffset.y = leftBottom ? size : 0; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else if (rotation < (90 + centerAnchorLimit)) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) labelOffset.x = -size * 0.4; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else if (rotation < 180) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) labelOffset.y = leftBottom ? 0 : -size; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else if (rotation < (270 - centerAnchorLimit)) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) labelOffset.y = leftBottom ? 0 : -size; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else if (rotation < (270 + centerAnchorLimit)) { ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) ->centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 3, 38)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) +>centerAnchorLimit : Symbol(centerAnchorLimit, Decl(controlFlowCaching.ts, 2, 38)) labelOffset.y = leftBottom ? size * 0.4 : 0; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } else { labelOffset.y = leftBottom ? size : 0; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 6, 72)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>leftBottom : Symbol(leftBottom, Decl(controlFlowCaching.ts, 5, 72)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) } } titleRotation = (taTitleOrientation && taTitleOrientation == "away") ? 180 : 0; ->titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 8, 30)) ->taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 14, 92)) ->taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 14, 92)) +>titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 7, 30)) +>taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 13, 92)) +>taTitleOrientation : Symbol(taTitleOrientation, Decl(controlFlowCaching.ts, 13, 92)) titlePos.y = offsets.t - titleOffset + (titleRotation ? 0 : tsize); ->titlePos : Symbol(titlePos, Decl(controlFlowCaching.ts, 8, 20)) ->offsets : Symbol(offsets, Decl(controlFlowCaching.ts, 3, 15)) ->titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 8, 49)) ->titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 8, 30)) ->tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 23, 60)) +>titlePos : Symbol(titlePos, Decl(controlFlowCaching.ts, 7, 20)) +>offsets : Symbol(offsets, Decl(controlFlowCaching.ts, 2, 15)) +>titleOffset : Symbol(titleOffset, Decl(controlFlowCaching.ts, 7, 49)) +>titleRotation : Symbol(titleRotation, Decl(controlFlowCaching.ts, 7, 30)) +>tsize : Symbol(tsize, Decl(controlFlowCaching.ts, 22, 60)) switch (labelAlign) { ->labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 8, 113)) +>labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 7, 113)) case "start": labelAlign = "end"; ->labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 8, 113)) +>labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 7, 113)) break; case "end": labelAlign = "start"; ->labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 8, 113)) +>labelAlign : Symbol(labelAlign, Decl(controlFlowCaching.ts, 7, 113)) break; case "middle": labelOffset.y -= size; ->labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 8, 100)) ->size : Symbol(size, Decl(controlFlowCaching.ts, 20, 56)) +>labelOffset : Symbol(labelOffset, Decl(controlFlowCaching.ts, 7, 100)) +>size : Symbol(size, Decl(controlFlowCaching.ts, 19, 56)) break; } let _ = rotation; ->_ : Symbol(_, Decl(controlFlowCaching.ts, 65, 7)) ->rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 7, 47)) +>_ : Symbol(_, Decl(controlFlowCaching.ts, 64, 7)) +>rotation : Symbol(rotation, Decl(controlFlowCaching.ts, 6, 47)) } diff --git a/tests/baselines/reference/controlFlowCaching.types b/tests/baselines/reference/controlFlowCaching.types index 4b7df020c9419..f78de65da5af8 100644 --- a/tests/baselines/reference/controlFlowCaching.types +++ b/tests/baselines/reference/controlFlowCaching.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowCaching.ts === - // Repro for #8401 function f(dim, offsets, arr, acommon, centerAnchorLimit, g, has, lin) { diff --git a/tests/baselines/reference/controlFlowDeleteOperator.errors.txt b/tests/baselines/reference/controlFlowDeleteOperator.errors.txt index a8cf358a29a7d..757f3629975f1 100644 --- a/tests/baselines/reference/controlFlowDeleteOperator.errors.txt +++ b/tests/baselines/reference/controlFlowDeleteOperator.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/controlFlow/controlFlowDeleteOperator.ts(15,12): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/controlFlow/controlFlowDeleteOperator.ts(14,12): error TS2703: The operand of a delete operator must be a property reference. ==== tests/cases/conformance/controlFlow/controlFlowDeleteOperator.ts (1 errors) ==== - function f() { let x: { a?: number | string, b: number | string } = { b: 1 }; x.a; diff --git a/tests/baselines/reference/controlFlowDeleteOperator.js b/tests/baselines/reference/controlFlowDeleteOperator.js index 36ac88467d2b7..71be5ca2de019 100644 --- a/tests/baselines/reference/controlFlowDeleteOperator.js +++ b/tests/baselines/reference/controlFlowDeleteOperator.js @@ -1,5 +1,4 @@ //// [controlFlowDeleteOperator.ts] - function f() { let x: { a?: number | string, b: number | string } = { b: 1 }; x.a; diff --git a/tests/baselines/reference/controlFlowDestructuringDeclaration.js b/tests/baselines/reference/controlFlowDestructuringDeclaration.js index 766fb6baeb298..39192f1baadf0 100644 --- a/tests/baselines/reference/controlFlowDestructuringDeclaration.js +++ b/tests/baselines/reference/controlFlowDestructuringDeclaration.js @@ -1,5 +1,4 @@ //// [controlFlowDestructuringDeclaration.ts] - function f1() { let x: string | number = 1; x; diff --git a/tests/baselines/reference/controlFlowDestructuringDeclaration.symbols b/tests/baselines/reference/controlFlowDestructuringDeclaration.symbols index 65f0e497942d7..ebdc2adfd1e83 100644 --- a/tests/baselines/reference/controlFlowDestructuringDeclaration.symbols +++ b/tests/baselines/reference/controlFlowDestructuringDeclaration.symbols @@ -1,164 +1,163 @@ === tests/cases/conformance/controlFlow/controlFlowDestructuringDeclaration.ts === - function f1() { >f1 : Symbol(f1, Decl(controlFlowDestructuringDeclaration.ts, 0, 0)) let x: string | number = 1; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 2, 7)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 1, 7)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 2, 7)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 1, 7)) let y: string | undefined = ""; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 4, 7)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 3, 7)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 4, 7)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 3, 7)) } function f2() { ->f2 : Symbol(f2, Decl(controlFlowDestructuringDeclaration.ts, 6, 1)) +>f2 : Symbol(f2, Decl(controlFlowDestructuringDeclaration.ts, 5, 1)) let [x]: [string | number] = [1]; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 9, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 8, 9)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 9, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 8, 9)) let [y]: [string | undefined] = [""]; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 11, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 10, 9)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 11, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 10, 9)) let [z = ""]: [string | undefined] = [undefined]; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 13, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 12, 9)) >undefined : Symbol(undefined) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 13, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 12, 9)) } function f3() { ->f3 : Symbol(f3, Decl(controlFlowDestructuringDeclaration.ts, 15, 1)) +>f3 : Symbol(f3, Decl(controlFlowDestructuringDeclaration.ts, 14, 1)) let [x]: (string | number)[] = [1]; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 18, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 17, 9)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 18, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 17, 9)) let [y]: (string | undefined)[] = [""]; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 20, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 19, 9)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 20, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 19, 9)) let [z = ""]: (string | undefined)[] = [undefined]; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 22, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 21, 9)) >undefined : Symbol(undefined) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 22, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 21, 9)) } function f4() { ->f4 : Symbol(f4, Decl(controlFlowDestructuringDeclaration.ts, 24, 1)) +>f4 : Symbol(f4, Decl(controlFlowDestructuringDeclaration.ts, 23, 1)) let { x }: { x: string | number } = { x: 1 }; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 27, 9)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 27, 16)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 27, 41)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 26, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 26, 16)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 26, 41)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 27, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 26, 9)) let { y }: { y: string | undefined } = { y: "" }; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 29, 9)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 29, 16)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 29, 44)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 28, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 28, 16)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 28, 44)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 29, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 28, 9)) let { z = "" }: { z: string | undefined } = { z: undefined }; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 31, 9)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 31, 21)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 31, 49)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 30, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 30, 21)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 30, 49)) >undefined : Symbol(undefined) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 31, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 30, 9)) } function f5() { ->f5 : Symbol(f5, Decl(controlFlowDestructuringDeclaration.ts, 33, 1)) +>f5 : Symbol(f5, Decl(controlFlowDestructuringDeclaration.ts, 32, 1)) let { x }: { x?: string | number } = { x: 1 }; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 36, 9)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 36, 16)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 36, 42)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 35, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 35, 16)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 35, 42)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 36, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 35, 9)) let { y }: { y?: string | undefined } = { y: "" }; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 38, 9)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 38, 16)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 38, 45)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 37, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 37, 16)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 37, 45)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 38, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 37, 9)) let { z = "" }: { z?: string | undefined } = { z: undefined }; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 40, 9)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 40, 21)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 40, 50)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 39, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 39, 21)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 39, 50)) >undefined : Symbol(undefined) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 40, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 39, 9)) } function f6() { ->f6 : Symbol(f6, Decl(controlFlowDestructuringDeclaration.ts, 42, 1)) +>f6 : Symbol(f6, Decl(controlFlowDestructuringDeclaration.ts, 41, 1)) let { x }: { x?: string | number } = {}; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 45, 9)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 45, 16)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 44, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 44, 16)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 45, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 44, 9)) let { y }: { y?: string | undefined } = {}; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 47, 9)) ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 47, 16)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 46, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 46, 16)) y; ->y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 47, 9)) +>y : Symbol(y, Decl(controlFlowDestructuringDeclaration.ts, 46, 9)) let { z = "" }: { z?: string | undefined } = {}; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 49, 9)) ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 49, 21)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 48, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 48, 21)) z; ->z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 49, 9)) +>z : Symbol(z, Decl(controlFlowDestructuringDeclaration.ts, 48, 9)) } function f7() { ->f7 : Symbol(f7, Decl(controlFlowDestructuringDeclaration.ts, 51, 1)) +>f7 : Symbol(f7, Decl(controlFlowDestructuringDeclaration.ts, 50, 1)) let o: { [x: string]: number } = { x: 1 }; ->o : Symbol(o, Decl(controlFlowDestructuringDeclaration.ts, 54, 7)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 14)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 38)) +>o : Symbol(o, Decl(controlFlowDestructuringDeclaration.ts, 53, 7)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 53, 14)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 53, 38)) let { x }: { [x: string]: string | number } = o; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 55, 9)) ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 55, 18)) ->o : Symbol(o, Decl(controlFlowDestructuringDeclaration.ts, 54, 7)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 18)) +>o : Symbol(o, Decl(controlFlowDestructuringDeclaration.ts, 53, 7)) x; ->x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 55, 9)) +>x : Symbol(x, Decl(controlFlowDestructuringDeclaration.ts, 54, 9)) } diff --git a/tests/baselines/reference/controlFlowDestructuringDeclaration.types b/tests/baselines/reference/controlFlowDestructuringDeclaration.types index d50b743b74642..2815f2e1884b2 100644 --- a/tests/baselines/reference/controlFlowDestructuringDeclaration.types +++ b/tests/baselines/reference/controlFlowDestructuringDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowDestructuringDeclaration.ts === - function f1() { >f1 : () => void diff --git a/tests/baselines/reference/controlFlowIIFE.js b/tests/baselines/reference/controlFlowIIFE.js index 5d295b57315f7..20bde01cba612 100644 --- a/tests/baselines/reference/controlFlowIIFE.js +++ b/tests/baselines/reference/controlFlowIIFE.js @@ -1,5 +1,4 @@ //// [controlFlowIIFE.ts] - declare function getStringOrNumber(): string | number; function f1() { diff --git a/tests/baselines/reference/controlFlowIIFE.symbols b/tests/baselines/reference/controlFlowIIFE.symbols index b1b2b74115874..4df906e06842b 100644 --- a/tests/baselines/reference/controlFlowIIFE.symbols +++ b/tests/baselines/reference/controlFlowIIFE.symbols @@ -1,24 +1,23 @@ === tests/cases/conformance/controlFlow/controlFlowIIFE.ts === - declare function getStringOrNumber(): string | number; >getStringOrNumber : Symbol(getStringOrNumber, Decl(controlFlowIIFE.ts, 0, 0)) function f1() { ->f1 : Symbol(f1, Decl(controlFlowIIFE.ts, 1, 54)) +>f1 : Symbol(f1, Decl(controlFlowIIFE.ts, 0, 54)) let x = getStringOrNumber(); ->x : Symbol(x, Decl(controlFlowIIFE.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 3, 7)) >getStringOrNumber : Symbol(getStringOrNumber, Decl(controlFlowIIFE.ts, 0, 0)) if (typeof x === "string") { ->x : Symbol(x, Decl(controlFlowIIFE.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 3, 7)) let n = function() { ->n : Symbol(n, Decl(controlFlowIIFE.ts, 6, 11)) +>n : Symbol(n, Decl(controlFlowIIFE.ts, 5, 11)) return x.length; >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIIFE.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 3, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) }(); @@ -26,21 +25,21 @@ function f1() { } function f2() { ->f2 : Symbol(f2, Decl(controlFlowIIFE.ts, 10, 1)) +>f2 : Symbol(f2, Decl(controlFlowIIFE.ts, 9, 1)) let x = getStringOrNumber(); ->x : Symbol(x, Decl(controlFlowIIFE.ts, 13, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 12, 7)) >getStringOrNumber : Symbol(getStringOrNumber, Decl(controlFlowIIFE.ts, 0, 0)) if (typeof x === "string") { ->x : Symbol(x, Decl(controlFlowIIFE.ts, 13, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 12, 7)) let n = (function() { ->n : Symbol(n, Decl(controlFlowIIFE.ts, 15, 11)) +>n : Symbol(n, Decl(controlFlowIIFE.ts, 14, 11)) return x.length; >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIIFE.ts, 13, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 12, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) })(); @@ -48,56 +47,56 @@ function f2() { } function f3() { ->f3 : Symbol(f3, Decl(controlFlowIIFE.ts, 19, 1)) +>f3 : Symbol(f3, Decl(controlFlowIIFE.ts, 18, 1)) let x = getStringOrNumber(); ->x : Symbol(x, Decl(controlFlowIIFE.ts, 22, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 21, 7)) >getStringOrNumber : Symbol(getStringOrNumber, Decl(controlFlowIIFE.ts, 0, 0)) let y: number; ->y : Symbol(y, Decl(controlFlowIIFE.ts, 23, 7)) +>y : Symbol(y, Decl(controlFlowIIFE.ts, 22, 7)) if (typeof x === "string") { ->x : Symbol(x, Decl(controlFlowIIFE.ts, 22, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 21, 7)) let n = (z => x.length + y + z)(y = 1); ->n : Symbol(n, Decl(controlFlowIIFE.ts, 25, 11)) ->z : Symbol(z, Decl(controlFlowIIFE.ts, 25, 17)) +>n : Symbol(n, Decl(controlFlowIIFE.ts, 24, 11)) +>z : Symbol(z, Decl(controlFlowIIFE.ts, 24, 17)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIIFE.ts, 22, 7)) +>x : Symbol(x, Decl(controlFlowIIFE.ts, 21, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->y : Symbol(y, Decl(controlFlowIIFE.ts, 23, 7)) ->z : Symbol(z, Decl(controlFlowIIFE.ts, 25, 17)) ->y : Symbol(y, Decl(controlFlowIIFE.ts, 23, 7)) +>y : Symbol(y, Decl(controlFlowIIFE.ts, 22, 7)) +>z : Symbol(z, Decl(controlFlowIIFE.ts, 24, 17)) +>y : Symbol(y, Decl(controlFlowIIFE.ts, 22, 7)) } } // Repros from #8381 let maybeNumber: number | undefined; ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) (function () { maybeNumber = 1; ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) })(); maybeNumber++; ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) if (maybeNumber !== undefined) { ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) >undefined : Symbol(undefined) maybeNumber++; ->maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 31, 3)) +>maybeNumber : Symbol(maybeNumber, Decl(controlFlowIIFE.ts, 30, 3)) } let test: string | undefined; ->test : Symbol(test, Decl(controlFlowIIFE.ts, 40, 3)) +>test : Symbol(test, Decl(controlFlowIIFE.ts, 39, 3)) if (!test) { ->test : Symbol(test, Decl(controlFlowIIFE.ts, 40, 3)) +>test : Symbol(test, Decl(controlFlowIIFE.ts, 39, 3)) throw new Error('Test is not defined'); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) @@ -105,7 +104,7 @@ if (!test) { (() => { test.slice(1); // No error >test.slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) ->test : Symbol(test, Decl(controlFlowIIFE.ts, 40, 3)) +>test : Symbol(test, Decl(controlFlowIIFE.ts, 39, 3)) >slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) })(); diff --git a/tests/baselines/reference/controlFlowIIFE.types b/tests/baselines/reference/controlFlowIIFE.types index 1c2e82903941f..1132649ae09d0 100644 --- a/tests/baselines/reference/controlFlowIIFE.types +++ b/tests/baselines/reference/controlFlowIIFE.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowIIFE.ts === - declare function getStringOrNumber(): string | number; >getStringOrNumber : () => string | number diff --git a/tests/baselines/reference/controlFlowIfStatement.js b/tests/baselines/reference/controlFlowIfStatement.js index 5b09b13e5fdd1..e40b831552f3d 100644 --- a/tests/baselines/reference/controlFlowIfStatement.js +++ b/tests/baselines/reference/controlFlowIfStatement.js @@ -1,5 +1,4 @@ //// [controlFlowIfStatement.ts] - let x: string | number | boolean | RegExp; let cond: boolean; diff --git a/tests/baselines/reference/controlFlowIfStatement.symbols b/tests/baselines/reference/controlFlowIfStatement.symbols index 29d235de780ff..e4d2bb9f184c0 100644 --- a/tests/baselines/reference/controlFlowIfStatement.symbols +++ b/tests/baselines/reference/controlFlowIfStatement.symbols @@ -1,113 +1,112 @@ === tests/cases/conformance/controlFlow/controlFlowIfStatement.ts === - let x: string | number | boolean | RegExp; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) let cond: boolean; ->cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 2, 3)) +>cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 1, 3)) x = /a/; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) if (x /* RegExp */, (x = true)) { ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) x; // boolean ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) x = ""; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) } else { x; // boolean ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) x = 42; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) } x; // string | number ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 1, 3)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3)) function a() { ->a : Symbol(a, Decl(controlFlowIfStatement.ts, 13, 2)) +>a : Symbol(a, Decl(controlFlowIfStatement.ts, 12, 2)) let x: string | number; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 16, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 2, 3)) +>cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 1, 3)) x = 42; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 16, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7)) } else { x = ""; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 16, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7)) return; } x; // number ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 16, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7)) } function b() { ->b : Symbol(b, Decl(controlFlowIfStatement.ts, 25, 1)) +>b : Symbol(b, Decl(controlFlowIfStatement.ts, 24, 1)) let x: string | number; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 2, 3)) +>cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 1, 3)) x = 42; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7)) throw ""; } else { x = ""; ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7)) } x; // string ->x : Symbol(x, Decl(controlFlowIfStatement.ts, 27, 7)) +>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7)) } function c(data: string | T): T { ->c : Symbol(c, Decl(controlFlowIfStatement.ts, 36, 1)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 37, 11)) ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 37, 14)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 37, 11)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 37, 11)) +>c : Symbol(c, Decl(controlFlowIfStatement.ts, 35, 1)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 36, 11)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 36, 11)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 36, 11)) if (typeof data === 'string') { ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 37, 14)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14)) return JSON.parse(data); >JSON.parse : Symbol(JSON.parse, Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >parse : Symbol(JSON.parse, Decl(lib.d.ts, --, --)) ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 37, 14)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14)) } else { return data; ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 37, 14)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14)) } } function d(data: string | T): never { ->d : Symbol(d, Decl(controlFlowIfStatement.ts, 44, 1)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 45, 11)) ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 45, 29)) ->T : Symbol(T, Decl(controlFlowIfStatement.ts, 45, 11)) +>d : Symbol(d, Decl(controlFlowIfStatement.ts, 43, 1)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 44, 11)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 44, 29)) +>T : Symbol(T, Decl(controlFlowIfStatement.ts, 44, 11)) if (typeof data === 'string') { ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 45, 29)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 44, 29)) throw new Error('will always happen'); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } else { return data; ->data : Symbol(data, Decl(controlFlowIfStatement.ts, 45, 29)) +>data : Symbol(data, Decl(controlFlowIfStatement.ts, 44, 29)) } } diff --git a/tests/baselines/reference/controlFlowIfStatement.types b/tests/baselines/reference/controlFlowIfStatement.types index e0ce68db7b15e..7c745735c9efd 100644 --- a/tests/baselines/reference/controlFlowIfStatement.types +++ b/tests/baselines/reference/controlFlowIfStatement.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowIfStatement.ts === - let x: string | number | boolean | RegExp; >x : string | number | boolean | RegExp >RegExp : RegExp diff --git a/tests/baselines/reference/controlFlowInstanceof.js b/tests/baselines/reference/controlFlowInstanceof.js index 3f2287b46285a..89a8a7a3ddfbe 100644 --- a/tests/baselines/reference/controlFlowInstanceof.js +++ b/tests/baselines/reference/controlFlowInstanceof.js @@ -1,5 +1,4 @@ //// [controlFlowInstanceof.ts] - // Repros from #10167 function f1(s: Set | Set) { diff --git a/tests/baselines/reference/controlFlowInstanceof.symbols b/tests/baselines/reference/controlFlowInstanceof.symbols index 19304ada88826..299bacbb8fec9 100644 --- a/tests/baselines/reference/controlFlowInstanceof.symbols +++ b/tests/baselines/reference/controlFlowInstanceof.symbols @@ -1,232 +1,231 @@ === tests/cases/compiler/controlFlowInstanceof.ts === - // Repros from #10167 function f1(s: Set | Set) { >f1 : Symbol(f1, Decl(controlFlowInstanceof.ts, 0, 0)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s = new Set(); ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) if (s instanceof Set) { ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) } s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) s.add(42); >s.add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12)) >add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --)) } function f2(s: Set | Set) { ->f2 : Symbol(f2, Decl(controlFlowInstanceof.ts, 11, 1)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>f2 : Symbol(f2, Decl(controlFlowInstanceof.ts, 10, 1)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s = new Set(); ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) if (s instanceof Promise) { ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) s; // Set & Promise ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) } s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) s.add(42); >s.add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12)) >add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --)) } function f3(s: Set | Set) { ->f3 : Symbol(f3, Decl(controlFlowInstanceof.ts, 21, 1)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>f3 : Symbol(f3, Decl(controlFlowInstanceof.ts, 20, 1)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set | Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) if (s instanceof Set) { ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set | Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) } else { s; // never ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12)) } } function f4(s: Set | Set) { ->f4 : Symbol(f4, Decl(controlFlowInstanceof.ts, 31, 1)) ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>f4 : Symbol(f4, Decl(controlFlowInstanceof.ts, 30, 1)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s = new Set(); ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) if (s instanceof Set) { ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) >Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) s; // Set ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) } else { s; // never ->s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12)) +>s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12)) } } // More tests class A { a: string } ->A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1)) ->a : Symbol(A.a, Decl(controlFlowInstanceof.ts, 46, 9)) +>A : Symbol(A, Decl(controlFlowInstanceof.ts, 41, 1)) +>a : Symbol(A.a, Decl(controlFlowInstanceof.ts, 45, 9)) class B extends A { b: string } ->B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21)) ->A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1)) ->b : Symbol(B.b, Decl(controlFlowInstanceof.ts, 47, 19)) +>B : Symbol(B, Decl(controlFlowInstanceof.ts, 45, 21)) +>A : Symbol(A, Decl(controlFlowInstanceof.ts, 41, 1)) +>b : Symbol(B.b, Decl(controlFlowInstanceof.ts, 46, 19)) class C extends A { c: string } ->C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31)) ->A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1)) ->c : Symbol(C.c, Decl(controlFlowInstanceof.ts, 48, 19)) +>C : Symbol(C, Decl(controlFlowInstanceof.ts, 46, 31)) +>A : Symbol(A, Decl(controlFlowInstanceof.ts, 41, 1)) +>c : Symbol(C.c, Decl(controlFlowInstanceof.ts, 47, 19)) function foo(x: A | undefined) { ->foo : Symbol(foo, Decl(controlFlowInstanceof.ts, 48, 31)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1)) +>foo : Symbol(foo, Decl(controlFlowInstanceof.ts, 47, 31)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>A : Symbol(A, Decl(controlFlowInstanceof.ts, 41, 1)) x; // A | undefined ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (x instanceof B || x instanceof C) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>B : Symbol(B, Decl(controlFlowInstanceof.ts, 45, 21)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>C : Symbol(C, Decl(controlFlowInstanceof.ts, 46, 31)) x; // B | C ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } x; // A | undefined ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (x instanceof B && x instanceof C) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>B : Symbol(B, Decl(controlFlowInstanceof.ts, 45, 21)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>C : Symbol(C, Decl(controlFlowInstanceof.ts, 46, 31)) x; // B & C ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } x; // A | undefined ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (!x) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) return; } x; // A ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (x instanceof B) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>B : Symbol(B, Decl(controlFlowInstanceof.ts, 45, 21)) x; // B ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) if (x instanceof C) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) ->C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) +>C : Symbol(C, Decl(controlFlowInstanceof.ts, 46, 31)) x; // B & C ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } else { x; // B ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } x; // B ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } else { x; // A ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } x; // A ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 49, 13)) } // X is neither assignable to Y nor a subtype of Y // Y is assignable to X, but not a subtype of X interface X { ->X : Symbol(X, Decl(controlFlowInstanceof.ts, 78, 1)) +>X : Symbol(X, Decl(controlFlowInstanceof.ts, 77, 1)) x?: string; ->x : Symbol(X.x, Decl(controlFlowInstanceof.ts, 83, 13)) +>x : Symbol(X.x, Decl(controlFlowInstanceof.ts, 82, 13)) } class Y { ->Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 85, 1)) +>Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 84, 1)) y: string; ->y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 87, 9)) +>y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 86, 9)) } function goo(x: X) { ->goo : Symbol(goo, Decl(controlFlowInstanceof.ts, 89, 1)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) ->X : Symbol(X, Decl(controlFlowInstanceof.ts, 78, 1)) +>goo : Symbol(goo, Decl(controlFlowInstanceof.ts, 88, 1)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) +>X : Symbol(X, Decl(controlFlowInstanceof.ts, 77, 1)) x; ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) if (x instanceof Y) { ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) ->Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 85, 1)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) +>Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 84, 1)) x.y; ->x.y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 87, 9)) ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) ->y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 87, 9)) +>x.y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 86, 9)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) +>y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 86, 9)) } x; ->x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13)) +>x : Symbol(x, Decl(controlFlowInstanceof.ts, 90, 13)) } diff --git a/tests/baselines/reference/controlFlowInstanceof.types b/tests/baselines/reference/controlFlowInstanceof.types index 3dc9fff8b0456..16d1ec71462f0 100644 --- a/tests/baselines/reference/controlFlowInstanceof.types +++ b/tests/baselines/reference/controlFlowInstanceof.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowInstanceof.ts === - // Repros from #10167 function f1(s: Set | Set) { diff --git a/tests/baselines/reference/controlFlowIteration.js b/tests/baselines/reference/controlFlowIteration.js index 7b319ba80987e..775d9f2408304 100644 --- a/tests/baselines/reference/controlFlowIteration.js +++ b/tests/baselines/reference/controlFlowIteration.js @@ -1,5 +1,4 @@ //// [controlFlowIteration.ts] - let cond: boolean; function ff() { diff --git a/tests/baselines/reference/controlFlowIteration.symbols b/tests/baselines/reference/controlFlowIteration.symbols index 84c1c57b69b6e..1bd53194dccdc 100644 --- a/tests/baselines/reference/controlFlowIteration.symbols +++ b/tests/baselines/reference/controlFlowIteration.symbols @@ -1,36 +1,35 @@ === tests/cases/conformance/controlFlow/controlFlowIteration.ts === - let cond: boolean; ->cond : Symbol(cond, Decl(controlFlowIteration.ts, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowIteration.ts, 0, 3)) function ff() { ->ff : Symbol(ff, Decl(controlFlowIteration.ts, 1, 18)) +>ff : Symbol(ff, Decl(controlFlowIteration.ts, 0, 18)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) while (true) { if (cond) { ->cond : Symbol(cond, Decl(controlFlowIteration.ts, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowIteration.ts, 0, 3)) x = ""; ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) } else { if (x) { ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) x.length; >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } if (x) { ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) x.length; >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(controlFlowIteration.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowIteration.ts, 3, 7)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/controlFlowIteration.types b/tests/baselines/reference/controlFlowIteration.types index a8c05b9732fa9..652dfc0c7cd90 100644 --- a/tests/baselines/reference/controlFlowIteration.types +++ b/tests/baselines/reference/controlFlowIteration.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowIteration.ts === - let cond: boolean; >cond : boolean diff --git a/tests/baselines/reference/controlFlowIterationErrors.errors.txt b/tests/baselines/reference/controlFlowIterationErrors.errors.txt index bc4b19b0602bd..28cbf8bdc478a 100644 --- a/tests/baselines/reference/controlFlowIterationErrors.errors.txt +++ b/tests/baselines/reference/controlFlowIterationErrors.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(12,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'string'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(11,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'string'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(23,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'string'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(22,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'string'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(35,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'number'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(34,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'number'. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(46,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'number'. +tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts(45,17): error TS2345: Argument of type 'string | number' is not assignable to parameter of type 'number'. Type 'string' is not assignable to type 'number'. ==== tests/cases/conformance/controlFlow/controlFlowIterationErrors.ts (4 errors) ==== - let cond: boolean; function len(s: string) { diff --git a/tests/baselines/reference/controlFlowIterationErrors.js b/tests/baselines/reference/controlFlowIterationErrors.js index eed54cc53a797..504016310896e 100644 --- a/tests/baselines/reference/controlFlowIterationErrors.js +++ b/tests/baselines/reference/controlFlowIterationErrors.js @@ -1,5 +1,4 @@ //// [controlFlowIterationErrors.ts] - let cond: boolean; function len(s: string) { diff --git a/tests/baselines/reference/controlFlowJavascript.js b/tests/baselines/reference/controlFlowJavascript.js index 66518a6567a2c..c119d5da62385 100644 --- a/tests/baselines/reference/controlFlowJavascript.js +++ b/tests/baselines/reference/controlFlowJavascript.js @@ -1,5 +1,4 @@ //// [controlFlowJavascript.js] - let cond = true; // CFA for 'let' and no initializer diff --git a/tests/baselines/reference/controlFlowJavascript.symbols b/tests/baselines/reference/controlFlowJavascript.symbols index b3316de3b4e81..6d35ec7481f7a 100644 --- a/tests/baselines/reference/controlFlowJavascript.symbols +++ b/tests/baselines/reference/controlFlowJavascript.symbols @@ -1,215 +1,214 @@ === tests/cases/compiler/controlFlowJavascript.js === - let cond = true; ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) // CFA for 'let' and no initializer function f1() { ->f1 : Symbol(f1, Decl(controlFlowJavascript.js, 1, 16)) +>f1 : Symbol(f1, Decl(controlFlowJavascript.js, 0, 16)) let x; ->x : Symbol(x, Decl(controlFlowJavascript.js, 5, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 4, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 5, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 4, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 5, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 4, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 12, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 5, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 11, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 4, 7)) } // CFA for 'let' and 'undefined' initializer function f2() { ->f2 : Symbol(f2, Decl(controlFlowJavascript.js, 13, 1)) +>f2 : Symbol(f2, Decl(controlFlowJavascript.js, 12, 1)) let x = undefined; ->x : Symbol(x, Decl(controlFlowJavascript.js, 17, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 16, 7)) >undefined : Symbol(undefined) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 17, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 16, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 17, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 16, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 24, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 17, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 23, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 16, 7)) } // CFA for 'let' and 'null' initializer function f3() { ->f3 : Symbol(f3, Decl(controlFlowJavascript.js, 25, 1)) +>f3 : Symbol(f3, Decl(controlFlowJavascript.js, 24, 1)) let x = null; ->x : Symbol(x, Decl(controlFlowJavascript.js, 29, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 28, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 29, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 28, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 29, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 28, 7)) } const y = x; // string | number | null ->y : Symbol(y, Decl(controlFlowJavascript.js, 36, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 29, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 35, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 28, 7)) } // CFA for 'var' with no initializer function f5() { ->f5 : Symbol(f5, Decl(controlFlowJavascript.js, 37, 1)) +>f5 : Symbol(f5, Decl(controlFlowJavascript.js, 36, 1)) var x; ->x : Symbol(x, Decl(controlFlowJavascript.js, 41, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 40, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 41, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 40, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 41, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 40, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 48, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 41, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 47, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 40, 7)) } // CFA for 'var' with 'undefined' initializer function f6() { ->f6 : Symbol(f6, Decl(controlFlowJavascript.js, 49, 1)) +>f6 : Symbol(f6, Decl(controlFlowJavascript.js, 48, 1)) var x = undefined; ->x : Symbol(x, Decl(controlFlowJavascript.js, 53, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 52, 7)) >undefined : Symbol(undefined) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 53, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 52, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 53, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 52, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 60, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 53, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 59, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 52, 7)) } // CFA for 'var' with 'null' initializer function f7() { ->f7 : Symbol(f7, Decl(controlFlowJavascript.js, 61, 1)) +>f7 : Symbol(f7, Decl(controlFlowJavascript.js, 60, 1)) var x = null; ->x : Symbol(x, Decl(controlFlowJavascript.js, 65, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 64, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 65, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 64, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 65, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 64, 7)) } const y = x; // string | number | null ->y : Symbol(y, Decl(controlFlowJavascript.js, 72, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 65, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 71, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 64, 7)) } // No CFA for captured outer variables function f9() { ->f9 : Symbol(f9, Decl(controlFlowJavascript.js, 73, 1)) +>f9 : Symbol(f9, Decl(controlFlowJavascript.js, 72, 1)) let x; ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 84, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 83, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) function f() { ->f : Symbol(f, Decl(controlFlowJavascript.js, 84, 16)) +>f : Symbol(f, Decl(controlFlowJavascript.js, 83, 16)) const z = x; // any ->z : Symbol(z, Decl(controlFlowJavascript.js, 86, 13)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 77, 7)) +>z : Symbol(z, Decl(controlFlowJavascript.js, 85, 13)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 76, 7)) } } // No CFA for captured outer variables function f10() { ->f10 : Symbol(f10, Decl(controlFlowJavascript.js, 88, 1)) +>f10 : Symbol(f10, Decl(controlFlowJavascript.js, 87, 1)) let x; ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = 1; ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) } if (cond) { ->cond : Symbol(cond, Decl(controlFlowJavascript.js, 1, 3)) +>cond : Symbol(cond, Decl(controlFlowJavascript.js, 0, 3)) x = "hello"; ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) } const y = x; // string | number | undefined ->y : Symbol(y, Decl(controlFlowJavascript.js, 99, 9)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>y : Symbol(y, Decl(controlFlowJavascript.js, 98, 9)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) const f = () => { ->f : Symbol(f, Decl(controlFlowJavascript.js, 100, 9)) +>f : Symbol(f, Decl(controlFlowJavascript.js, 99, 9)) const z = x; // any ->z : Symbol(z, Decl(controlFlowJavascript.js, 101, 13)) ->x : Symbol(x, Decl(controlFlowJavascript.js, 92, 7)) +>z : Symbol(z, Decl(controlFlowJavascript.js, 100, 13)) +>x : Symbol(x, Decl(controlFlowJavascript.js, 91, 7)) }; } diff --git a/tests/baselines/reference/controlFlowJavascript.types b/tests/baselines/reference/controlFlowJavascript.types index 0b88c62cb785a..2ac8c19bf1b05 100644 --- a/tests/baselines/reference/controlFlowJavascript.types +++ b/tests/baselines/reference/controlFlowJavascript.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowJavascript.js === - let cond = true; >cond : boolean >true : true diff --git a/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt b/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt index 0d08f93a8a8c2..68266dde43e1a 100644 --- a/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt +++ b/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/controlFlowLoopAnalysis.ts(13,25): error TS2345: Argument of type 'number | undefined' is not assignable to parameter of type 'number'. +tests/cases/compiler/controlFlowLoopAnalysis.ts(12,25): error TS2345: Argument of type 'number | undefined' is not assignable to parameter of type 'number'. Type 'undefined' is not assignable to type 'number'. ==== tests/cases/compiler/controlFlowLoopAnalysis.ts (1 errors) ==== - // Repro from #8418 let cond: boolean; diff --git a/tests/baselines/reference/controlFlowLoopAnalysis.js b/tests/baselines/reference/controlFlowLoopAnalysis.js index 77384ddedcfb4..fa8dc29e92a9c 100644 --- a/tests/baselines/reference/controlFlowLoopAnalysis.js +++ b/tests/baselines/reference/controlFlowLoopAnalysis.js @@ -1,5 +1,4 @@ //// [controlFlowLoopAnalysis.ts] - // Repro from #8418 let cond: boolean; diff --git a/tests/baselines/reference/controlFlowNoImplicitAny.errors.txt b/tests/baselines/reference/controlFlowNoImplicitAny.errors.txt index d081f29d51112..3684fc1b51b81 100644 --- a/tests/baselines/reference/controlFlowNoImplicitAny.errors.txt +++ b/tests/baselines/reference/controlFlowNoImplicitAny.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/controlFlowNoImplicitAny.ts(102,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowNoImplicitAny.ts(111,19): error TS7005: Variable 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowNoImplicitAny.ts(117,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. -tests/cases/compiler/controlFlowNoImplicitAny.ts(126,19): error TS7005: Variable 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowNoImplicitAny.ts(101,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowNoImplicitAny.ts(110,19): error TS7005: Variable 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowNoImplicitAny.ts(116,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. +tests/cases/compiler/controlFlowNoImplicitAny.ts(125,19): error TS7005: Variable 'x' implicitly has an 'any' type. ==== tests/cases/compiler/controlFlowNoImplicitAny.ts (4 errors) ==== - declare let cond: boolean; // CFA for 'let' with no type annotation and initializer diff --git a/tests/baselines/reference/controlFlowNoImplicitAny.js b/tests/baselines/reference/controlFlowNoImplicitAny.js index 9a5f302d87a39..1b0cb41b7e24a 100644 --- a/tests/baselines/reference/controlFlowNoImplicitAny.js +++ b/tests/baselines/reference/controlFlowNoImplicitAny.js @@ -1,5 +1,4 @@ //// [controlFlowNoImplicitAny.ts] - declare let cond: boolean; // CFA for 'let' with no type annotation and initializer diff --git a/tests/baselines/reference/controlFlowOuterVariable.js b/tests/baselines/reference/controlFlowOuterVariable.js index 1925d75eb31c4..55b83640cd944 100644 --- a/tests/baselines/reference/controlFlowOuterVariable.js +++ b/tests/baselines/reference/controlFlowOuterVariable.js @@ -1,5 +1,4 @@ //// [controlFlowOuterVariable.ts] - // Repros from #10641 const CONFIG = { diff --git a/tests/baselines/reference/controlFlowOuterVariable.symbols b/tests/baselines/reference/controlFlowOuterVariable.symbols index 35974f28a8634..590878752f570 100644 --- a/tests/baselines/reference/controlFlowOuterVariable.symbols +++ b/tests/baselines/reference/controlFlowOuterVariable.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/controlFlowOuterVariable.ts === - // Repros from #10641 const CONFIG = { ->CONFIG : Symbol(CONFIG, Decl(controlFlowOuterVariable.ts, 3, 5)) +>CONFIG : Symbol(CONFIG, Decl(controlFlowOuterVariable.ts, 2, 5)) foo: '', ->foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 3, 16)) +>foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 2, 16)) setFoo: function(foo: string) { ->setFoo : Symbol(setFoo, Decl(controlFlowOuterVariable.ts, 4, 12)) ->foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 5, 21)) +>setFoo : Symbol(setFoo, Decl(controlFlowOuterVariable.ts, 3, 12)) +>foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 4, 21)) CONFIG.foo = foo; ->CONFIG.foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 3, 16)) ->CONFIG : Symbol(CONFIG, Decl(controlFlowOuterVariable.ts, 3, 5)) ->foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 3, 16)) ->foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 5, 21)) +>CONFIG.foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 2, 16)) +>CONFIG : Symbol(CONFIG, Decl(controlFlowOuterVariable.ts, 2, 5)) +>foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 2, 16)) +>foo : Symbol(foo, Decl(controlFlowOuterVariable.ts, 4, 21)) } }; const helper = function(t: T[]) { ->helper : Symbol(helper, Decl(controlFlowOuterVariable.ts, 10, 5)) ->T : Symbol(T, Decl(controlFlowOuterVariable.ts, 10, 24)) ->t : Symbol(t, Decl(controlFlowOuterVariable.ts, 10, 27)) ->T : Symbol(T, Decl(controlFlowOuterVariable.ts, 10, 24)) +>helper : Symbol(helper, Decl(controlFlowOuterVariable.ts, 9, 5)) +>T : Symbol(T, Decl(controlFlowOuterVariable.ts, 9, 24)) +>t : Symbol(t, Decl(controlFlowOuterVariable.ts, 9, 27)) +>T : Symbol(T, Decl(controlFlowOuterVariable.ts, 9, 24)) helper(t.slice(1)); ->helper : Symbol(helper, Decl(controlFlowOuterVariable.ts, 10, 5)) +>helper : Symbol(helper, Decl(controlFlowOuterVariable.ts, 9, 5)) >t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) ->t : Symbol(t, Decl(controlFlowOuterVariable.ts, 10, 27)) +>t : Symbol(t, Decl(controlFlowOuterVariable.ts, 9, 27)) >slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/controlFlowOuterVariable.types b/tests/baselines/reference/controlFlowOuterVariable.types index 859542e70e197..10d46d10bfc30 100644 --- a/tests/baselines/reference/controlFlowOuterVariable.types +++ b/tests/baselines/reference/controlFlowOuterVariable.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowOuterVariable.ts === - // Repros from #10641 const CONFIG = { diff --git a/tests/baselines/reference/controlFlowPropertyDeclarations.js b/tests/baselines/reference/controlFlowPropertyDeclarations.js index 27fce9a9a1288..ab286b27f06ef 100644 --- a/tests/baselines/reference/controlFlowPropertyDeclarations.js +++ b/tests/baselines/reference/controlFlowPropertyDeclarations.js @@ -149,8 +149,8 @@ export class StyleParser { } //// [controlFlowPropertyDeclarations.js] -// Repro from ##8913 "use strict"; +// Repro from ##8913 exports.__esModule = true; var HTMLDOMPropertyConfig = require('react/lib/HTMLDOMPropertyConfig'); // Populate property map with ReactJS's attribute and property mappings diff --git a/tests/baselines/reference/controlFlowPropertyInitializer.js b/tests/baselines/reference/controlFlowPropertyInitializer.js index 5d8e10651fa77..dda9a2690bcf6 100644 --- a/tests/baselines/reference/controlFlowPropertyInitializer.js +++ b/tests/baselines/reference/controlFlowPropertyInitializer.js @@ -1,5 +1,4 @@ //// [controlFlowPropertyInitializer.ts] - // Repro from #8967 const LANG = "Turbo Pascal" diff --git a/tests/baselines/reference/controlFlowPropertyInitializer.symbols b/tests/baselines/reference/controlFlowPropertyInitializer.symbols index 70e6c2da8a17d..be8ae00a905cf 100644 --- a/tests/baselines/reference/controlFlowPropertyInitializer.symbols +++ b/tests/baselines/reference/controlFlowPropertyInitializer.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/controlFlowPropertyInitializer.ts === - // Repro from #8967 const LANG = "Turbo Pascal" ->LANG : Symbol(LANG, Decl(controlFlowPropertyInitializer.ts, 3, 5)) +>LANG : Symbol(LANG, Decl(controlFlowPropertyInitializer.ts, 2, 5)) class BestLanguage { ->BestLanguage : Symbol(BestLanguage, Decl(controlFlowPropertyInitializer.ts, 3, 27)) +>BestLanguage : Symbol(BestLanguage, Decl(controlFlowPropertyInitializer.ts, 2, 27)) name = LANG; ->name : Symbol(BestLanguage.name, Decl(controlFlowPropertyInitializer.ts, 5, 20)) ->LANG : Symbol(LANG, Decl(controlFlowPropertyInitializer.ts, 3, 5)) +>name : Symbol(BestLanguage.name, Decl(controlFlowPropertyInitializer.ts, 4, 20)) +>LANG : Symbol(LANG, Decl(controlFlowPropertyInitializer.ts, 2, 5)) } diff --git a/tests/baselines/reference/controlFlowPropertyInitializer.types b/tests/baselines/reference/controlFlowPropertyInitializer.types index 7da8fefe958b6..ff3d757287bc5 100644 --- a/tests/baselines/reference/controlFlowPropertyInitializer.types +++ b/tests/baselines/reference/controlFlowPropertyInitializer.types @@ -1,5 +1,4 @@ === tests/cases/compiler/controlFlowPropertyInitializer.ts === - // Repro from #8967 const LANG = "Turbo Pascal" diff --git a/tests/baselines/reference/controlFlowSelfReferentialLoop.errors.txt b/tests/baselines/reference/controlFlowSelfReferentialLoop.errors.txt index deef640376128..69f670359afb4 100644 --- a/tests/baselines/reference/controlFlowSelfReferentialLoop.errors.txt +++ b/tests/baselines/reference/controlFlowSelfReferentialLoop.errors.txt @@ -1,35 +1,34 @@ -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,17): error TS7006: Parameter 'a' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,19): error TS7006: Parameter 'b' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,21): error TS7006: Parameter 'c' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,23): error TS7006: Parameter 'd' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,27): error TS7006: Parameter 's' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(6,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,17): error TS7006: Parameter 'a' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,19): error TS7006: Parameter 'b' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,21): error TS7006: Parameter 'c' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,23): error TS7006: Parameter 'd' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,27): error TS7006: Parameter 's' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(10,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,17): error TS7006: Parameter 'a' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,19): error TS7006: Parameter 'b' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,21): error TS7006: Parameter 'c' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,23): error TS7006: Parameter 'd' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,27): error TS7006: Parameter 's' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(14,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,17): error TS7006: Parameter 'a' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,19): error TS7006: Parameter 'b' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,21): error TS7006: Parameter 'c' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,23): error TS7006: Parameter 'd' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,27): error TS7006: Parameter 's' implicitly has an 'any' type. -tests/cases/compiler/controlFlowSelfReferentialLoop.ts(18,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,17): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,19): error TS7006: Parameter 'b' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,21): error TS7006: Parameter 'c' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,23): error TS7006: Parameter 'd' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,27): error TS7006: Parameter 's' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(5,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,17): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,19): error TS7006: Parameter 'b' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,21): error TS7006: Parameter 'c' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,23): error TS7006: Parameter 'd' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,27): error TS7006: Parameter 's' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(9,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,17): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,19): error TS7006: Parameter 'b' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,21): error TS7006: Parameter 'c' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,23): error TS7006: Parameter 'd' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,27): error TS7006: Parameter 's' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(13,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,17): error TS7006: Parameter 'a' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,19): error TS7006: Parameter 'b' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,21): error TS7006: Parameter 'c' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,23): error TS7006: Parameter 'd' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,27): error TS7006: Parameter 's' implicitly has an 'any' type. +tests/cases/compiler/controlFlowSelfReferentialLoop.ts(17,29): error TS7006: Parameter 'ac' implicitly has an 'any' type. ==== tests/cases/compiler/controlFlowSelfReferentialLoop.ts (28 errors) ==== - // Repro from #12319 function md5(string:string): void { diff --git a/tests/baselines/reference/controlFlowSelfReferentialLoop.js b/tests/baselines/reference/controlFlowSelfReferentialLoop.js index 0a7eff198ff81..4781f2776fbf5 100644 --- a/tests/baselines/reference/controlFlowSelfReferentialLoop.js +++ b/tests/baselines/reference/controlFlowSelfReferentialLoop.js @@ -1,5 +1,4 @@ //// [controlFlowSelfReferentialLoop.ts] - // Repro from #12319 function md5(string:string): void { @@ -102,8 +101,8 @@ function md5(string:string): void { export default md5; //// [controlFlowSelfReferentialLoop.js] -// Repro from #12319 "use strict"; +// Repro from #12319 exports.__esModule = true; function md5(string) { function FF(a, b, c, d, x, s, ac) { diff --git a/tests/baselines/reference/controlFlowSuperPropertyAccess.js b/tests/baselines/reference/controlFlowSuperPropertyAccess.js new file mode 100644 index 0000000000000..c2f947d56878e --- /dev/null +++ b/tests/baselines/reference/controlFlowSuperPropertyAccess.js @@ -0,0 +1,37 @@ +//// [controlFlowSuperPropertyAccess.ts] +class B { + protected m?(): void; +} +class C extends B { + body() { + super.m && super.m(); + } +} + + +//// [controlFlowSuperPropertyAccess.js] +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var B = (function () { + function B() { + } + return B; +}()); +var C = (function (_super) { + __extends(C, _super); + function C() { + return _super !== null && _super.apply(this, arguments) || this; + } + C.prototype.body = function () { + _super.prototype.m && _super.prototype.m.call(this); + }; + return C; +}(B)); diff --git a/tests/baselines/reference/controlFlowSuperPropertyAccess.symbols b/tests/baselines/reference/controlFlowSuperPropertyAccess.symbols new file mode 100644 index 0000000000000..7b7053f96fa47 --- /dev/null +++ b/tests/baselines/reference/controlFlowSuperPropertyAccess.symbols @@ -0,0 +1,24 @@ +=== tests/cases/conformance/controlFlow/controlFlowSuperPropertyAccess.ts === +class B { +>B : Symbol(B, Decl(controlFlowSuperPropertyAccess.ts, 0, 0)) + + protected m?(): void; +>m : Symbol(B.m, Decl(controlFlowSuperPropertyAccess.ts, 0, 9)) +} +class C extends B { +>C : Symbol(C, Decl(controlFlowSuperPropertyAccess.ts, 2, 1)) +>B : Symbol(B, Decl(controlFlowSuperPropertyAccess.ts, 0, 0)) + + body() { +>body : Symbol(C.body, Decl(controlFlowSuperPropertyAccess.ts, 3, 19)) + + super.m && super.m(); +>super.m : Symbol(B.m, Decl(controlFlowSuperPropertyAccess.ts, 0, 9)) +>super : Symbol(B, Decl(controlFlowSuperPropertyAccess.ts, 0, 0)) +>m : Symbol(B.m, Decl(controlFlowSuperPropertyAccess.ts, 0, 9)) +>super.m : Symbol(B.m, Decl(controlFlowSuperPropertyAccess.ts, 0, 9)) +>super : Symbol(B, Decl(controlFlowSuperPropertyAccess.ts, 0, 0)) +>m : Symbol(B.m, Decl(controlFlowSuperPropertyAccess.ts, 0, 9)) + } +} + diff --git a/tests/baselines/reference/controlFlowSuperPropertyAccess.types b/tests/baselines/reference/controlFlowSuperPropertyAccess.types new file mode 100644 index 0000000000000..87e7b3f00d0bc --- /dev/null +++ b/tests/baselines/reference/controlFlowSuperPropertyAccess.types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/controlFlow/controlFlowSuperPropertyAccess.ts === +class B { +>B : B + + protected m?(): void; +>m : (() => void) | undefined +} +class C extends B { +>C : C +>B : B + + body() { +>body : () => void + + super.m && super.m(); +>super.m && super.m() : void | undefined +>super.m : (() => void) | undefined +>super : B +>m : (() => void) | undefined +>super.m() : void +>super.m : () => void +>super : B +>m : () => void + } +} + diff --git a/tests/baselines/reference/controlFlowTruthiness.js b/tests/baselines/reference/controlFlowTruthiness.js index b595bcbd18096..b57befbd6415a 100644 --- a/tests/baselines/reference/controlFlowTruthiness.js +++ b/tests/baselines/reference/controlFlowTruthiness.js @@ -1,5 +1,4 @@ //// [controlFlowTruthiness.ts] - declare function foo(): string | undefined; function f1() { diff --git a/tests/baselines/reference/controlFlowTruthiness.symbols b/tests/baselines/reference/controlFlowTruthiness.symbols index 37c1fb135f2c0..72dd304f8106d 100644 --- a/tests/baselines/reference/controlFlowTruthiness.symbols +++ b/tests/baselines/reference/controlFlowTruthiness.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/controlFlow/controlFlowTruthiness.ts === - declare function foo(): string | undefined; >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) function f1() { ->f1 : Symbol(f1, Decl(controlFlowTruthiness.ts, 1, 43)) +>f1 : Symbol(f1, Decl(controlFlowTruthiness.ts, 0, 43)) let x = foo(); ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 3, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) if (x) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 3, 7)) x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 3, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 4, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 3, 7)) } } function f2() { ->f2 : Symbol(f2, Decl(controlFlowTruthiness.ts, 11, 1)) +>f2 : Symbol(f2, Decl(controlFlowTruthiness.ts, 10, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) x = foo(); ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) if (x) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 14, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 13, 7)) } } function f3() { ->f3 : Symbol(f3, Decl(controlFlowTruthiness.ts, 22, 1)) +>f3 : Symbol(f3, Decl(controlFlowTruthiness.ts, 21, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 25, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 24, 7)) if (x = foo()) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 25, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 24, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 25, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 24, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 25, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 24, 7)) } } function f4() { ->f4 : Symbol(f4, Decl(controlFlowTruthiness.ts, 32, 1)) +>f4 : Symbol(f4, Decl(controlFlowTruthiness.ts, 31, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 35, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 34, 7)) if (!(x = foo())) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 35, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 34, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 35, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 34, 7)) } else { x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 35, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 34, 7)) } } function f5() { ->f5 : Symbol(f5, Decl(controlFlowTruthiness.ts, 42, 1)) +>f5 : Symbol(f5, Decl(controlFlowTruthiness.ts, 41, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 45, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 44, 7)) let y: string | undefined; ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 46, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 45, 7)) if (x = y = foo()) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 45, 7)) ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 46, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 44, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 45, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) x; // string ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 45, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 44, 7)) y; // string | undefined ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 46, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 45, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 45, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 44, 7)) y; // string | undefined ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 46, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 45, 7)) } } function f6() { ->f6 : Symbol(f6, Decl(controlFlowTruthiness.ts, 55, 1)) +>f6 : Symbol(f6, Decl(controlFlowTruthiness.ts, 54, 1)) let x: string | undefined; ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 58, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 57, 7)) let y: string | undefined; ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 59, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 58, 7)) if (x = foo(), y = foo()) { ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 58, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 57, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 59, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 58, 7)) >foo : Symbol(foo, Decl(controlFlowTruthiness.ts, 0, 0)) x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 58, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 57, 7)) y; // string ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 59, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 58, 7)) } else { x; // string | undefined ->x : Symbol(x, Decl(controlFlowTruthiness.ts, 58, 7)) +>x : Symbol(x, Decl(controlFlowTruthiness.ts, 57, 7)) y; // string | undefined ->y : Symbol(y, Decl(controlFlowTruthiness.ts, 59, 7)) +>y : Symbol(y, Decl(controlFlowTruthiness.ts, 58, 7)) } } diff --git a/tests/baselines/reference/controlFlowTruthiness.types b/tests/baselines/reference/controlFlowTruthiness.types index 2d35856fe8340..225f6d0e7e25b 100644 --- a/tests/baselines/reference/controlFlowTruthiness.types +++ b/tests/baselines/reference/controlFlowTruthiness.types @@ -1,5 +1,4 @@ === tests/cases/conformance/controlFlow/controlFlowTruthiness.ts === - declare function foo(): string | undefined; >foo : () => string | undefined diff --git a/tests/baselines/reference/declFileAccessors.js b/tests/baselines/reference/declFileAccessors.js index 64a99bb84382c..a6e47b935c3b9 100644 --- a/tests/baselines/reference/declFileAccessors.js +++ b/tests/baselines/reference/declFileAccessors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileAccessors.ts] //// //// [declFileAccessors_0.ts] - /** This is comment for c1*/ export class c1 { /** getter property*/ diff --git a/tests/baselines/reference/declFileAccessors.symbols b/tests/baselines/reference/declFileAccessors.symbols index 3de90051ec487..e43f19c1e8c73 100644 --- a/tests/baselines/reference/declFileAccessors.symbols +++ b/tests/baselines/reference/declFileAccessors.symbols @@ -1,81 +1,80 @@ === tests/cases/compiler/declFileAccessors_0.ts === - /** This is comment for c1*/ export class c1 { >c1 : Symbol(c1, Decl(declFileAccessors_0.ts, 0, 0)) /** getter property*/ public get p3() { ->p3 : Symbol(c1.p3, Decl(declFileAccessors_0.ts, 2, 17), Decl(declFileAccessors_0.ts, 6, 5)) +>p3 : Symbol(c1.p3, Decl(declFileAccessors_0.ts, 1, 17), Decl(declFileAccessors_0.ts, 5, 5)) return 10; } /** setter property*/ public set p3(/** this is value*/value: number) { ->p3 : Symbol(c1.p3, Decl(declFileAccessors_0.ts, 2, 17), Decl(declFileAccessors_0.ts, 6, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 8, 18)) +>p3 : Symbol(c1.p3, Decl(declFileAccessors_0.ts, 1, 17), Decl(declFileAccessors_0.ts, 5, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 7, 18)) } /** private getter property*/ private get pp3() { ->pp3 : Symbol(c1.pp3, Decl(declFileAccessors_0.ts, 9, 5), Decl(declFileAccessors_0.ts, 13, 5)) +>pp3 : Symbol(c1.pp3, Decl(declFileAccessors_0.ts, 8, 5), Decl(declFileAccessors_0.ts, 12, 5)) return 10; } /** private setter property*/ private set pp3(/** this is value*/value: number) { ->pp3 : Symbol(c1.pp3, Decl(declFileAccessors_0.ts, 9, 5), Decl(declFileAccessors_0.ts, 13, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 15, 20)) +>pp3 : Symbol(c1.pp3, Decl(declFileAccessors_0.ts, 8, 5), Decl(declFileAccessors_0.ts, 12, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 14, 20)) } /** static getter property*/ static get s3() { ->s3 : Symbol(c1.s3, Decl(declFileAccessors_0.ts, 16, 5), Decl(declFileAccessors_0.ts, 20, 5)) +>s3 : Symbol(c1.s3, Decl(declFileAccessors_0.ts, 15, 5), Decl(declFileAccessors_0.ts, 19, 5)) return 10; } /** setter property*/ static set s3( /** this is value*/value: number) { ->s3 : Symbol(c1.s3, Decl(declFileAccessors_0.ts, 16, 5), Decl(declFileAccessors_0.ts, 20, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 22, 18)) +>s3 : Symbol(c1.s3, Decl(declFileAccessors_0.ts, 15, 5), Decl(declFileAccessors_0.ts, 19, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 21, 18)) } public get nc_p3() { ->nc_p3 : Symbol(c1.nc_p3, Decl(declFileAccessors_0.ts, 23, 5), Decl(declFileAccessors_0.ts, 26, 5)) +>nc_p3 : Symbol(c1.nc_p3, Decl(declFileAccessors_0.ts, 22, 5), Decl(declFileAccessors_0.ts, 25, 5)) return 10; } public set nc_p3(value: number) { ->nc_p3 : Symbol(c1.nc_p3, Decl(declFileAccessors_0.ts, 23, 5), Decl(declFileAccessors_0.ts, 26, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 27, 21)) +>nc_p3 : Symbol(c1.nc_p3, Decl(declFileAccessors_0.ts, 22, 5), Decl(declFileAccessors_0.ts, 25, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 26, 21)) } private get nc_pp3() { ->nc_pp3 : Symbol(c1.nc_pp3, Decl(declFileAccessors_0.ts, 28, 5), Decl(declFileAccessors_0.ts, 31, 5)) +>nc_pp3 : Symbol(c1.nc_pp3, Decl(declFileAccessors_0.ts, 27, 5), Decl(declFileAccessors_0.ts, 30, 5)) return 10; } private set nc_pp3(value: number) { ->nc_pp3 : Symbol(c1.nc_pp3, Decl(declFileAccessors_0.ts, 28, 5), Decl(declFileAccessors_0.ts, 31, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 32, 23)) +>nc_pp3 : Symbol(c1.nc_pp3, Decl(declFileAccessors_0.ts, 27, 5), Decl(declFileAccessors_0.ts, 30, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 31, 23)) } static get nc_s3() { ->nc_s3 : Symbol(c1.nc_s3, Decl(declFileAccessors_0.ts, 33, 5), Decl(declFileAccessors_0.ts, 36, 5)) +>nc_s3 : Symbol(c1.nc_s3, Decl(declFileAccessors_0.ts, 32, 5), Decl(declFileAccessors_0.ts, 35, 5)) return ""; } static set nc_s3(value: string) { ->nc_s3 : Symbol(c1.nc_s3, Decl(declFileAccessors_0.ts, 33, 5), Decl(declFileAccessors_0.ts, 36, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 37, 21)) +>nc_s3 : Symbol(c1.nc_s3, Decl(declFileAccessors_0.ts, 32, 5), Decl(declFileAccessors_0.ts, 35, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 36, 21)) } // Only getter property public get onlyGetter() { ->onlyGetter : Symbol(c1.onlyGetter, Decl(declFileAccessors_0.ts, 38, 5)) +>onlyGetter : Symbol(c1.onlyGetter, Decl(declFileAccessors_0.ts, 37, 5)) return 10; } // Only setter property public set onlySetter(value: number) { ->onlySetter : Symbol(c1.onlySetter, Decl(declFileAccessors_0.ts, 43, 5)) ->value : Symbol(value, Decl(declFileAccessors_0.ts, 46, 26)) +>onlySetter : Symbol(c1.onlySetter, Decl(declFileAccessors_0.ts, 42, 5)) +>value : Symbol(value, Decl(declFileAccessors_0.ts, 45, 26)) } } diff --git a/tests/baselines/reference/declFileAccessors.types b/tests/baselines/reference/declFileAccessors.types index a038c66b271bc..797f5433e4219 100644 --- a/tests/baselines/reference/declFileAccessors.types +++ b/tests/baselines/reference/declFileAccessors.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileAccessors_0.ts === - /** This is comment for c1*/ export class c1 { >c1 : c1 diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.js b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.js index 56b8992811b39..2269f85996f92 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.js +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileAliasUseBeforeDeclaration.ts] //// //// [declFileAliasUseBeforeDeclaration_foo.ts] - export class Foo { } //// [declFileAliasUseBeforeDeclaration_test.ts] diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.symbols b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.symbols index ba74b6cdfb7cf..cd890bf4256e9 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.symbols +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.symbols @@ -9,7 +9,6 @@ import foo = require("./declFileAliasUseBeforeDeclaration_foo"); >foo : Symbol(foo, Decl(declFileAliasUseBeforeDeclaration_test.ts, 0, 35)) === tests/cases/compiler/declFileAliasUseBeforeDeclaration_foo.ts === - export class Foo { } >Foo : Symbol(Foo, Decl(declFileAliasUseBeforeDeclaration_foo.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.types b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.types index 544efded5eeeb..0b2c98e808ca9 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration.types +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration.types @@ -9,7 +9,6 @@ import foo = require("./declFileAliasUseBeforeDeclaration_foo"); >foo : typeof foo === tests/cases/compiler/declFileAliasUseBeforeDeclaration_foo.ts === - export class Foo { } >Foo : Foo diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.js b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.js index 905a298bd32f5..ef8db581de4a4 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.js +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.js @@ -1,5 +1,4 @@ //// [declFileAliasUseBeforeDeclaration2.ts] - declare module "test" { module A { class C { diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.symbols b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.symbols index c0ad98bbe3d90..16cd0938541cb 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.symbols +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.symbols @@ -1,19 +1,18 @@ === tests/cases/compiler/declFileAliasUseBeforeDeclaration2.ts === - declare module "test" { module A { ->A : Symbol(A, Decl(declFileAliasUseBeforeDeclaration2.ts, 1, 23)) +>A : Symbol(A, Decl(declFileAliasUseBeforeDeclaration2.ts, 0, 23)) class C { ->C : Symbol(C, Decl(declFileAliasUseBeforeDeclaration2.ts, 2, 14)) +>C : Symbol(C, Decl(declFileAliasUseBeforeDeclaration2.ts, 1, 14)) } } class B extends E { ->B : Symbol(B, Decl(declFileAliasUseBeforeDeclaration2.ts, 5, 5)) ->E : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 7, 5)) +>B : Symbol(B, Decl(declFileAliasUseBeforeDeclaration2.ts, 4, 5)) +>E : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 6, 5)) } import E = A.C; ->E : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 7, 5)) ->A : Symbol(A, Decl(declFileAliasUseBeforeDeclaration2.ts, 1, 23)) ->C : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 2, 14)) +>E : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 6, 5)) +>A : Symbol(A, Decl(declFileAliasUseBeforeDeclaration2.ts, 0, 23)) +>C : Symbol(E, Decl(declFileAliasUseBeforeDeclaration2.ts, 1, 14)) } diff --git a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.types b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.types index 362dd031e092e..a51c79e044c68 100644 --- a/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.types +++ b/tests/baselines/reference/declFileAliasUseBeforeDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileAliasUseBeforeDeclaration2.ts === - declare module "test" { module A { >A : typeof A diff --git a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.js b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.js index 6d626e2963df8..627a1865d8fc8 100644 --- a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.js +++ b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileAmbientExternalModuleWithSingleExportedModule.ts] //// //// [declFileAmbientExternalModuleWithSingleExportedModule_0.ts] - declare module "SubModule" { export module m { export module m3 { diff --git a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.symbols b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.symbols index 4a4077836cd2a..942d4a155f25d 100644 --- a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.symbols +++ b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.symbols @@ -6,22 +6,21 @@ import SubModule = require('SubModule'); export var x: SubModule.m.m3.c; >x : Symbol(x, Decl(declFileAmbientExternalModuleWithSingleExportedModule_1.ts, 2, 10)) >SubModule : Symbol(SubModule, Decl(declFileAmbientExternalModuleWithSingleExportedModule_1.ts, 0, 0)) ->m : Symbol(SubModule.m, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 1, 28)) ->m3 : Symbol(SubModule.m.m3, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 2, 21)) ->c : Symbol(SubModule.m.m3.c, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 3, 26)) +>m : Symbol(SubModule.m, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 0, 28)) +>m3 : Symbol(SubModule.m.m3, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 1, 21)) +>c : Symbol(SubModule.m.m3.c, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 2, 26)) === tests/cases/compiler/declFileAmbientExternalModuleWithSingleExportedModule_0.ts === - declare module "SubModule" { export module m { ->m : Symbol(m, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 1, 28)) +>m : Symbol(m, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 0, 28)) export module m3 { ->m3 : Symbol(m3, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 2, 21)) +>m3 : Symbol(m3, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 1, 21)) interface c { ->c : Symbol(c, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 3, 26)) +>c : Symbol(c, Decl(declFileAmbientExternalModuleWithSingleExportedModule_0.ts, 2, 26)) } } } diff --git a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.types b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.types index 792f1f0282f71..2332302ceadf2 100644 --- a/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.types +++ b/tests/baselines/reference/declFileAmbientExternalModuleWithSingleExportedModule.types @@ -12,7 +12,6 @@ export var x: SubModule.m.m3.c; === tests/cases/compiler/declFileAmbientExternalModuleWithSingleExportedModule_0.ts === - declare module "SubModule" { export module m { >m : any diff --git a/tests/baselines/reference/declFileCallSignatures.js b/tests/baselines/reference/declFileCallSignatures.js index 8f79ae6341e06..7c0e6d8b0a526 100644 --- a/tests/baselines/reference/declFileCallSignatures.js +++ b/tests/baselines/reference/declFileCallSignatures.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileCallSignatures.ts] //// //// [declFileCallSignatures_0.ts] - export interface ICallSignature { /** This comment should appear for foo*/ (): string; diff --git a/tests/baselines/reference/declFileCallSignatures.symbols b/tests/baselines/reference/declFileCallSignatures.symbols index cf1697dc4c0f4..2034ffe5bde46 100644 --- a/tests/baselines/reference/declFileCallSignatures.symbols +++ b/tests/baselines/reference/declFileCallSignatures.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileCallSignatures_0.ts === - export interface ICallSignature { >ICallSignature : Symbol(ICallSignature, Decl(declFileCallSignatures_0.ts, 0, 0)) @@ -8,53 +7,53 @@ export interface ICallSignature { } export interface ICallSignatureWithParameters { ->ICallSignatureWithParameters : Symbol(ICallSignatureWithParameters, Decl(declFileCallSignatures_0.ts, 4, 1)) +>ICallSignatureWithParameters : Symbol(ICallSignatureWithParameters, Decl(declFileCallSignatures_0.ts, 3, 1)) /** This is comment for function signature*/ (/** this is comment about a*/a: string, ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 8, 5)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 7, 5)) /** this is comment for b*/ b: number): void; ->b : Symbol(b, Decl(declFileCallSignatures_0.ts, 8, 44)) +>b : Symbol(b, Decl(declFileCallSignatures_0.ts, 7, 44)) } export interface ICallSignatureWithRestParameters { ->ICallSignatureWithRestParameters : Symbol(ICallSignatureWithRestParameters, Decl(declFileCallSignatures_0.ts, 11, 1)) +>ICallSignatureWithRestParameters : Symbol(ICallSignatureWithRestParameters, Decl(declFileCallSignatures_0.ts, 10, 1)) (a: string, ...rests: string[]): string; ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 14, 5)) ->rests : Symbol(rests, Decl(declFileCallSignatures_0.ts, 14, 15)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 13, 5)) +>rests : Symbol(rests, Decl(declFileCallSignatures_0.ts, 13, 15)) } export interface ICallSignatureWithOverloads { ->ICallSignatureWithOverloads : Symbol(ICallSignatureWithOverloads, Decl(declFileCallSignatures_0.ts, 15, 1)) +>ICallSignatureWithOverloads : Symbol(ICallSignatureWithOverloads, Decl(declFileCallSignatures_0.ts, 14, 1)) (a: string): string; ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 18, 5)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 17, 5)) (a: number): number; ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 19, 5)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 18, 5)) } export interface ICallSignatureWithTypeParameters { ->ICallSignatureWithTypeParameters : Symbol(ICallSignatureWithTypeParameters, Decl(declFileCallSignatures_0.ts, 20, 1)) ->T : Symbol(T, Decl(declFileCallSignatures_0.ts, 22, 50)) +>ICallSignatureWithTypeParameters : Symbol(ICallSignatureWithTypeParameters, Decl(declFileCallSignatures_0.ts, 19, 1)) +>T : Symbol(T, Decl(declFileCallSignatures_0.ts, 21, 50)) /** This comment should appear for foo*/ (a: T): string; ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 24, 5)) ->T : Symbol(T, Decl(declFileCallSignatures_0.ts, 22, 50)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 23, 5)) +>T : Symbol(T, Decl(declFileCallSignatures_0.ts, 21, 50)) } export interface ICallSignatureWithOwnTypeParametes { ->ICallSignatureWithOwnTypeParametes : Symbol(ICallSignatureWithOwnTypeParametes, Decl(declFileCallSignatures_0.ts, 25, 1)) +>ICallSignatureWithOwnTypeParametes : Symbol(ICallSignatureWithOwnTypeParametes, Decl(declFileCallSignatures_0.ts, 24, 1)) (a: T): string; ->T : Symbol(T, Decl(declFileCallSignatures_0.ts, 28, 5)) +>T : Symbol(T, Decl(declFileCallSignatures_0.ts, 27, 5)) >ICallSignature : Symbol(ICallSignature, Decl(declFileCallSignatures_0.ts, 0, 0)) ->a : Symbol(a, Decl(declFileCallSignatures_0.ts, 28, 31)) ->T : Symbol(T, Decl(declFileCallSignatures_0.ts, 28, 5)) +>a : Symbol(a, Decl(declFileCallSignatures_0.ts, 27, 31)) +>T : Symbol(T, Decl(declFileCallSignatures_0.ts, 27, 5)) } === tests/cases/compiler/declFileCallSignatures_1.ts === diff --git a/tests/baselines/reference/declFileCallSignatures.types b/tests/baselines/reference/declFileCallSignatures.types index 0fc0757aee1d1..ec5ab9a26cf5d 100644 --- a/tests/baselines/reference/declFileCallSignatures.types +++ b/tests/baselines/reference/declFileCallSignatures.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileCallSignatures_0.ts === - export interface ICallSignature { >ICallSignature : ICallSignature diff --git a/tests/baselines/reference/declFileClassExtendsNull.js b/tests/baselines/reference/declFileClassExtendsNull.js index a7ea02011fefa..5e2da40442b40 100644 --- a/tests/baselines/reference/declFileClassExtendsNull.js +++ b/tests/baselines/reference/declFileClassExtendsNull.js @@ -1,5 +1,4 @@ //// [declFileClassExtendsNull.ts] - class ExtendsNull extends null { } diff --git a/tests/baselines/reference/declFileClassExtendsNull.symbols b/tests/baselines/reference/declFileClassExtendsNull.symbols index e86276faad8b7..09e7744fa1653 100644 --- a/tests/baselines/reference/declFileClassExtendsNull.symbols +++ b/tests/baselines/reference/declFileClassExtendsNull.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileClassExtendsNull.ts === - class ExtendsNull extends null { >ExtendsNull : Symbol(ExtendsNull, Decl(declFileClassExtendsNull.ts, 0, 0)) } diff --git a/tests/baselines/reference/declFileClassExtendsNull.types b/tests/baselines/reference/declFileClassExtendsNull.types index bbd43d99c0da1..7fc519ac0d606 100644 --- a/tests/baselines/reference/declFileClassExtendsNull.types +++ b/tests/baselines/reference/declFileClassExtendsNull.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileClassExtendsNull.ts === - class ExtendsNull extends null { >ExtendsNull : ExtendsNull >null : null diff --git a/tests/baselines/reference/declFileClassWithIndexSignature.js b/tests/baselines/reference/declFileClassWithIndexSignature.js index 31369db666001..46969b1875533 100644 --- a/tests/baselines/reference/declFileClassWithIndexSignature.js +++ b/tests/baselines/reference/declFileClassWithIndexSignature.js @@ -1,5 +1,4 @@ //// [declFileClassWithIndexSignature.ts] - class BlockIntrinsics { [s: string]: string; } diff --git a/tests/baselines/reference/declFileClassWithIndexSignature.symbols b/tests/baselines/reference/declFileClassWithIndexSignature.symbols index 2487a2fae0051..5b0cce6df163f 100644 --- a/tests/baselines/reference/declFileClassWithIndexSignature.symbols +++ b/tests/baselines/reference/declFileClassWithIndexSignature.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/declFileClassWithIndexSignature.ts === - class BlockIntrinsics { >BlockIntrinsics : Symbol(BlockIntrinsics, Decl(declFileClassWithIndexSignature.ts, 0, 0)) [s: string]: string; ->s : Symbol(s, Decl(declFileClassWithIndexSignature.ts, 2, 5)) +>s : Symbol(s, Decl(declFileClassWithIndexSignature.ts, 1, 5)) } diff --git a/tests/baselines/reference/declFileClassWithIndexSignature.types b/tests/baselines/reference/declFileClassWithIndexSignature.types index 16aa108c3c1ee..5f587eb43a1c4 100644 --- a/tests/baselines/reference/declFileClassWithIndexSignature.types +++ b/tests/baselines/reference/declFileClassWithIndexSignature.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileClassWithIndexSignature.ts === - class BlockIntrinsics { >BlockIntrinsics : BlockIntrinsics diff --git a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.js b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.js index ee1964415c910..4ac309c1a6b21 100644 --- a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.js +++ b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.js @@ -1,5 +1,4 @@ //// [declFileClassWithStaticMethodReturningConstructor.ts] - export class Enhancement { public static getType() { return this; diff --git a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.symbols b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.symbols index af1f56642bc91..a08baa5017965 100644 --- a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.symbols +++ b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/declFileClassWithStaticMethodReturningConstructor.ts === - export class Enhancement { >Enhancement : Symbol(Enhancement, Decl(declFileClassWithStaticMethodReturningConstructor.ts, 0, 0)) public static getType() { ->getType : Symbol(Enhancement.getType, Decl(declFileClassWithStaticMethodReturningConstructor.ts, 1, 26)) +>getType : Symbol(Enhancement.getType, Decl(declFileClassWithStaticMethodReturningConstructor.ts, 0, 26)) return this; >this : Symbol(Enhancement, Decl(declFileClassWithStaticMethodReturningConstructor.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.types b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.types index 0f1b21efc9e17..cfecdccd4c697 100644 --- a/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.types +++ b/tests/baselines/reference/declFileClassWithStaticMethodReturningConstructor.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileClassWithStaticMethodReturningConstructor.ts === - export class Enhancement { >Enhancement : Enhancement diff --git a/tests/baselines/reference/declFileConstructSignatures.js b/tests/baselines/reference/declFileConstructSignatures.js index 309f71338733b..dd9dd7f8908ea 100644 --- a/tests/baselines/reference/declFileConstructSignatures.js +++ b/tests/baselines/reference/declFileConstructSignatures.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileConstructSignatures.ts] //// //// [declFileConstructSignatures_0.ts] - export interface IConstructSignature { /** This comment should appear for foo*/ new (): string; diff --git a/tests/baselines/reference/declFileConstructSignatures.symbols b/tests/baselines/reference/declFileConstructSignatures.symbols index a6d98f6feca00..29f6a3af50f39 100644 --- a/tests/baselines/reference/declFileConstructSignatures.symbols +++ b/tests/baselines/reference/declFileConstructSignatures.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileConstructSignatures_0.ts === - export interface IConstructSignature { >IConstructSignature : Symbol(IConstructSignature, Decl(declFileConstructSignatures_0.ts, 0, 0)) @@ -8,55 +7,55 @@ export interface IConstructSignature { } export interface IConstructSignatureWithParameters { ->IConstructSignatureWithParameters : Symbol(IConstructSignatureWithParameters, Decl(declFileConstructSignatures_0.ts, 4, 1)) +>IConstructSignatureWithParameters : Symbol(IConstructSignatureWithParameters, Decl(declFileConstructSignatures_0.ts, 3, 1)) /** This is comment for function signature*/ new (/** this is comment about a*/a: string, ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 8, 9)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 7, 9)) /** this is comment for b*/ b: number); ->b : Symbol(b, Decl(declFileConstructSignatures_0.ts, 8, 48)) +>b : Symbol(b, Decl(declFileConstructSignatures_0.ts, 7, 48)) } export interface IConstructSignatureWithRestParameters { ->IConstructSignatureWithRestParameters : Symbol(IConstructSignatureWithRestParameters, Decl(declFileConstructSignatures_0.ts, 11, 1)) +>IConstructSignatureWithRestParameters : Symbol(IConstructSignatureWithRestParameters, Decl(declFileConstructSignatures_0.ts, 10, 1)) new (a: string, ...rests: string[]): string; ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 14, 9)) ->rests : Symbol(rests, Decl(declFileConstructSignatures_0.ts, 14, 19)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 13, 9)) +>rests : Symbol(rests, Decl(declFileConstructSignatures_0.ts, 13, 19)) } export interface IConstructSignatureWithOverloads { ->IConstructSignatureWithOverloads : Symbol(IConstructSignatureWithOverloads, Decl(declFileConstructSignatures_0.ts, 15, 1)) +>IConstructSignatureWithOverloads : Symbol(IConstructSignatureWithOverloads, Decl(declFileConstructSignatures_0.ts, 14, 1)) new (a: string): string; ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 18, 9)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 17, 9)) new (a: number): number; ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 19, 9)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 18, 9)) } export interface IConstructSignatureWithTypeParameters { ->IConstructSignatureWithTypeParameters : Symbol(IConstructSignatureWithTypeParameters, Decl(declFileConstructSignatures_0.ts, 20, 1)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 22, 55)) +>IConstructSignatureWithTypeParameters : Symbol(IConstructSignatureWithTypeParameters, Decl(declFileConstructSignatures_0.ts, 19, 1)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 21, 55)) /** This comment should appear for foo*/ new (a: T): T; ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 24, 9)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 22, 55)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 22, 55)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 23, 9)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 21, 55)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 21, 55)) } export interface IConstructSignatureWithOwnTypeParametes { ->IConstructSignatureWithOwnTypeParametes : Symbol(IConstructSignatureWithOwnTypeParametes, Decl(declFileConstructSignatures_0.ts, 25, 1)) +>IConstructSignatureWithOwnTypeParametes : Symbol(IConstructSignatureWithOwnTypeParametes, Decl(declFileConstructSignatures_0.ts, 24, 1)) new (a: T): T; ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 28, 9)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 27, 9)) >IConstructSignature : Symbol(IConstructSignature, Decl(declFileConstructSignatures_0.ts, 0, 0)) ->a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 28, 40)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 28, 9)) ->T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 28, 9)) +>a : Symbol(a, Decl(declFileConstructSignatures_0.ts, 27, 40)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 27, 9)) +>T : Symbol(T, Decl(declFileConstructSignatures_0.ts, 27, 9)) } === tests/cases/compiler/declFileConstructSignatures_1.ts === diff --git a/tests/baselines/reference/declFileConstructSignatures.types b/tests/baselines/reference/declFileConstructSignatures.types index 6ee19bfdcf70c..72a73db82c605 100644 --- a/tests/baselines/reference/declFileConstructSignatures.types +++ b/tests/baselines/reference/declFileConstructSignatures.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileConstructSignatures_0.ts === - export interface IConstructSignature { >IConstructSignature : IConstructSignature diff --git a/tests/baselines/reference/declFileConstructors.js b/tests/baselines/reference/declFileConstructors.js index 214620193b796..95e28cc92d649 100644 --- a/tests/baselines/reference/declFileConstructors.js +++ b/tests/baselines/reference/declFileConstructors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileConstructors.ts] //// //// [declFileConstructors_0.ts] - export class SimpleConstructor { /** This comment should appear for foo*/ constructor() { diff --git a/tests/baselines/reference/declFileConstructors.symbols b/tests/baselines/reference/declFileConstructors.symbols index ad86b6a721f3f..2d7d1cd4a6a97 100644 --- a/tests/baselines/reference/declFileConstructors.symbols +++ b/tests/baselines/reference/declFileConstructors.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileConstructors_0.ts === - export class SimpleConstructor { >SimpleConstructor : Symbol(SimpleConstructor, Decl(declFileConstructors_0.ts, 0, 0)) @@ -8,80 +7,80 @@ export class SimpleConstructor { } } export class ConstructorWithParameters { ->ConstructorWithParameters : Symbol(ConstructorWithParameters, Decl(declFileConstructors_0.ts, 5, 1)) +>ConstructorWithParameters : Symbol(ConstructorWithParameters, Decl(declFileConstructors_0.ts, 4, 1)) /** This is comment for function signature*/ constructor(/** this is comment about a*/a: string, ->a : Symbol(a, Decl(declFileConstructors_0.ts, 8, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 7, 16)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileConstructors_0.ts, 8, 55)) +>b : Symbol(b, Decl(declFileConstructors_0.ts, 7, 55)) var d = a; ->d : Symbol(d, Decl(declFileConstructors_0.ts, 11, 11)) ->a : Symbol(a, Decl(declFileConstructors_0.ts, 8, 16)) +>d : Symbol(d, Decl(declFileConstructors_0.ts, 10, 11)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 7, 16)) } } export class ConstructorWithRestParamters { ->ConstructorWithRestParamters : Symbol(ConstructorWithRestParamters, Decl(declFileConstructors_0.ts, 13, 1)) +>ConstructorWithRestParamters : Symbol(ConstructorWithRestParamters, Decl(declFileConstructors_0.ts, 12, 1)) constructor(a: string, ...rests: string[]) { ->a : Symbol(a, Decl(declFileConstructors_0.ts, 16, 16)) ->rests : Symbol(rests, Decl(declFileConstructors_0.ts, 16, 26)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 15, 16)) +>rests : Symbol(rests, Decl(declFileConstructors_0.ts, 15, 26)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileConstructors_0.ts, 16, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 15, 16)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileConstructors_0.ts, 16, 26)) +>rests : Symbol(rests, Decl(declFileConstructors_0.ts, 15, 26)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } } export class ConstructorWithOverloads { ->ConstructorWithOverloads : Symbol(ConstructorWithOverloads, Decl(declFileConstructors_0.ts, 19, 1)) +>ConstructorWithOverloads : Symbol(ConstructorWithOverloads, Decl(declFileConstructors_0.ts, 18, 1)) constructor(a: string); ->a : Symbol(a, Decl(declFileConstructors_0.ts, 22, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 21, 16)) constructor(a: number); ->a : Symbol(a, Decl(declFileConstructors_0.ts, 23, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 22, 16)) constructor(a: any) { ->a : Symbol(a, Decl(declFileConstructors_0.ts, 24, 16)) +>a : Symbol(a, Decl(declFileConstructors_0.ts, 23, 16)) } } export class ConstructorWithPublicParameterProperty { ->ConstructorWithPublicParameterProperty : Symbol(ConstructorWithPublicParameterProperty, Decl(declFileConstructors_0.ts, 26, 1)) +>ConstructorWithPublicParameterProperty : Symbol(ConstructorWithPublicParameterProperty, Decl(declFileConstructors_0.ts, 25, 1)) constructor(public x: string) { ->x : Symbol(ConstructorWithPublicParameterProperty.x, Decl(declFileConstructors_0.ts, 29, 16)) +>x : Symbol(ConstructorWithPublicParameterProperty.x, Decl(declFileConstructors_0.ts, 28, 16)) } } export class ConstructorWithPrivateParameterProperty { ->ConstructorWithPrivateParameterProperty : Symbol(ConstructorWithPrivateParameterProperty, Decl(declFileConstructors_0.ts, 31, 1)) +>ConstructorWithPrivateParameterProperty : Symbol(ConstructorWithPrivateParameterProperty, Decl(declFileConstructors_0.ts, 30, 1)) constructor(private x: string) { ->x : Symbol(ConstructorWithPrivateParameterProperty.x, Decl(declFileConstructors_0.ts, 34, 16)) +>x : Symbol(ConstructorWithPrivateParameterProperty.x, Decl(declFileConstructors_0.ts, 33, 16)) } } export class ConstructorWithOptionalParameterProperty { ->ConstructorWithOptionalParameterProperty : Symbol(ConstructorWithOptionalParameterProperty, Decl(declFileConstructors_0.ts, 36, 1)) +>ConstructorWithOptionalParameterProperty : Symbol(ConstructorWithOptionalParameterProperty, Decl(declFileConstructors_0.ts, 35, 1)) constructor(public x?: string) { ->x : Symbol(ConstructorWithOptionalParameterProperty.x, Decl(declFileConstructors_0.ts, 39, 16)) +>x : Symbol(ConstructorWithOptionalParameterProperty.x, Decl(declFileConstructors_0.ts, 38, 16)) } } export class ConstructorWithParameterInitializer { ->ConstructorWithParameterInitializer : Symbol(ConstructorWithParameterInitializer, Decl(declFileConstructors_0.ts, 41, 1)) +>ConstructorWithParameterInitializer : Symbol(ConstructorWithParameterInitializer, Decl(declFileConstructors_0.ts, 40, 1)) constructor(public x = "hello") { ->x : Symbol(ConstructorWithParameterInitializer.x, Decl(declFileConstructors_0.ts, 44, 16)) +>x : Symbol(ConstructorWithParameterInitializer.x, Decl(declFileConstructors_0.ts, 43, 16)) } } diff --git a/tests/baselines/reference/declFileConstructors.types b/tests/baselines/reference/declFileConstructors.types index 733a624e776be..179db643bcb77 100644 --- a/tests/baselines/reference/declFileConstructors.types +++ b/tests/baselines/reference/declFileConstructors.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileConstructors_0.ts === - export class SimpleConstructor { >SimpleConstructor : SimpleConstructor diff --git a/tests/baselines/reference/declFileEnumUsedAsValue.js b/tests/baselines/reference/declFileEnumUsedAsValue.js index c42f70402b389..23afd5da8b0d3 100644 --- a/tests/baselines/reference/declFileEnumUsedAsValue.js +++ b/tests/baselines/reference/declFileEnumUsedAsValue.js @@ -1,5 +1,4 @@ //// [declFileEnumUsedAsValue.ts] - enum e { a, b, diff --git a/tests/baselines/reference/declFileEnumUsedAsValue.symbols b/tests/baselines/reference/declFileEnumUsedAsValue.symbols index d24852c6260c6..d0409fe02112d 100644 --- a/tests/baselines/reference/declFileEnumUsedAsValue.symbols +++ b/tests/baselines/reference/declFileEnumUsedAsValue.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/declFileEnumUsedAsValue.ts === - enum e { >e : Symbol(e, Decl(declFileEnumUsedAsValue.ts, 0, 0)) a, ->a : Symbol(e.a, Decl(declFileEnumUsedAsValue.ts, 1, 8)) +>a : Symbol(e.a, Decl(declFileEnumUsedAsValue.ts, 0, 8)) b, ->b : Symbol(e.b, Decl(declFileEnumUsedAsValue.ts, 2, 6)) +>b : Symbol(e.b, Decl(declFileEnumUsedAsValue.ts, 1, 6)) c ->c : Symbol(e.c, Decl(declFileEnumUsedAsValue.ts, 3, 6)) +>c : Symbol(e.c, Decl(declFileEnumUsedAsValue.ts, 2, 6)) } var x = e; ->x : Symbol(x, Decl(declFileEnumUsedAsValue.ts, 6, 3)) +>x : Symbol(x, Decl(declFileEnumUsedAsValue.ts, 5, 3)) >e : Symbol(e, Decl(declFileEnumUsedAsValue.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileEnumUsedAsValue.types b/tests/baselines/reference/declFileEnumUsedAsValue.types index fe32309592292..d4601cbacaeea 100644 --- a/tests/baselines/reference/declFileEnumUsedAsValue.types +++ b/tests/baselines/reference/declFileEnumUsedAsValue.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileEnumUsedAsValue.ts === - enum e { >e : e diff --git a/tests/baselines/reference/declFileEnums.js b/tests/baselines/reference/declFileEnums.js index 34f1e386a964a..d8027ca442f12 100644 --- a/tests/baselines/reference/declFileEnums.js +++ b/tests/baselines/reference/declFileEnums.js @@ -1,5 +1,4 @@ //// [declFileEnums.ts] - enum e1 { a, b, diff --git a/tests/baselines/reference/declFileEnums.symbols b/tests/baselines/reference/declFileEnums.symbols index bea118ea96729..e236509f6b188 100644 --- a/tests/baselines/reference/declFileEnums.symbols +++ b/tests/baselines/reference/declFileEnums.symbols @@ -1,70 +1,69 @@ === tests/cases/compiler/declFileEnums.ts === - enum e1 { >e1 : Symbol(e1, Decl(declFileEnums.ts, 0, 0)) a, ->a : Symbol(e1.a, Decl(declFileEnums.ts, 1, 9)) +>a : Symbol(e1.a, Decl(declFileEnums.ts, 0, 9)) b, ->b : Symbol(e1.b, Decl(declFileEnums.ts, 2, 6)) +>b : Symbol(e1.b, Decl(declFileEnums.ts, 1, 6)) c ->c : Symbol(e1.c, Decl(declFileEnums.ts, 3, 6)) +>c : Symbol(e1.c, Decl(declFileEnums.ts, 2, 6)) } enum e2 { ->e2 : Symbol(e2, Decl(declFileEnums.ts, 5, 1)) +>e2 : Symbol(e2, Decl(declFileEnums.ts, 4, 1)) a = 10, ->a : Symbol(e2.a, Decl(declFileEnums.ts, 7, 9)) +>a : Symbol(e2.a, Decl(declFileEnums.ts, 6, 9)) b = a + 2, ->b : Symbol(e2.b, Decl(declFileEnums.ts, 8, 11)) ->a : Symbol(e2.a, Decl(declFileEnums.ts, 7, 9)) +>b : Symbol(e2.b, Decl(declFileEnums.ts, 7, 11)) +>a : Symbol(e2.a, Decl(declFileEnums.ts, 6, 9)) c = 10, ->c : Symbol(e2.c, Decl(declFileEnums.ts, 9, 14)) +>c : Symbol(e2.c, Decl(declFileEnums.ts, 8, 14)) } enum e3 { ->e3 : Symbol(e3, Decl(declFileEnums.ts, 11, 1)) +>e3 : Symbol(e3, Decl(declFileEnums.ts, 10, 1)) a = 10, ->a : Symbol(e3.a, Decl(declFileEnums.ts, 13, 9)) +>a : Symbol(e3.a, Decl(declFileEnums.ts, 12, 9)) b = Math.PI, ->b : Symbol(e3.b, Decl(declFileEnums.ts, 14, 11)) +>b : Symbol(e3.b, Decl(declFileEnums.ts, 13, 11)) >Math.PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) c = a + 3 ->c : Symbol(e3.c, Decl(declFileEnums.ts, 15, 16)) ->a : Symbol(e3.a, Decl(declFileEnums.ts, 13, 9)) +>c : Symbol(e3.c, Decl(declFileEnums.ts, 14, 16)) +>a : Symbol(e3.a, Decl(declFileEnums.ts, 12, 9)) } enum e4 { ->e4 : Symbol(e4, Decl(declFileEnums.ts, 17, 1)) +>e4 : Symbol(e4, Decl(declFileEnums.ts, 16, 1)) a, ->a : Symbol(e4.a, Decl(declFileEnums.ts, 19, 9)) +>a : Symbol(e4.a, Decl(declFileEnums.ts, 18, 9)) b, ->b : Symbol(e4.b, Decl(declFileEnums.ts, 20, 6)) +>b : Symbol(e4.b, Decl(declFileEnums.ts, 19, 6)) c, ->c : Symbol(e4.c, Decl(declFileEnums.ts, 21, 6)) +>c : Symbol(e4.c, Decl(declFileEnums.ts, 20, 6)) d = 10, ->d : Symbol(e4.d, Decl(declFileEnums.ts, 22, 6)) +>d : Symbol(e4.d, Decl(declFileEnums.ts, 21, 6)) e ->e : Symbol(e4.e, Decl(declFileEnums.ts, 23, 11)) +>e : Symbol(e4.e, Decl(declFileEnums.ts, 22, 11)) } enum e5 { ->e5 : Symbol(e5, Decl(declFileEnums.ts, 25, 1)) +>e5 : Symbol(e5, Decl(declFileEnums.ts, 24, 1)) "Friday", "Saturday", diff --git a/tests/baselines/reference/declFileEnums.types b/tests/baselines/reference/declFileEnums.types index 5b0bfff5beda7..eb13d3bbf6753 100644 --- a/tests/baselines/reference/declFileEnums.types +++ b/tests/baselines/reference/declFileEnums.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileEnums.ts === - enum e1 { >e1 : e1 diff --git a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.js b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.js index 1caa920719377..cefff0be4eac9 100644 --- a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.js +++ b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileExportAssignmentOfGenericInterface.ts] //// //// [declFileExportAssignmentOfGenericInterface_0.ts] - interface Foo { a: string; } diff --git a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.symbols b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.symbols index 34b1cbff341d0..4499c321c5e37 100644 --- a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.symbols +++ b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.symbols @@ -8,18 +8,17 @@ export var x: a>; >a : Symbol(a, Decl(declFileExportAssignmentOfGenericInterface_1.ts, 0, 0)) x.a; ->x.a : Symbol(a.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 1, 18)) +>x.a : Symbol(a.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 18)) >x : Symbol(x, Decl(declFileExportAssignmentOfGenericInterface_1.ts, 1, 10)) ->a : Symbol(a.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 1, 18)) +>a : Symbol(a.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 18)) === tests/cases/compiler/declFileExportAssignmentOfGenericInterface_0.ts === - interface Foo { >Foo : Symbol(Foo, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 0)) ->T : Symbol(T, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 1, 14)) +>T : Symbol(T, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 14)) a: string; ->a : Symbol(Foo.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 1, 18)) +>a : Symbol(Foo.a, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 18)) } export = Foo; >Foo : Symbol(Foo, Decl(declFileExportAssignmentOfGenericInterface_0.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.types b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.types index 59c604540b99e..126f63a6ac96d 100644 --- a/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.types +++ b/tests/baselines/reference/declFileExportAssignmentOfGenericInterface.types @@ -13,7 +13,6 @@ x.a; >a : string === tests/cases/compiler/declFileExportAssignmentOfGenericInterface_0.ts === - interface Foo { >Foo : Foo >T : T diff --git a/tests/baselines/reference/declFileExportImportChain.js b/tests/baselines/reference/declFileExportImportChain.js index 2af2103b62a62..fe1b36d76fa48 100644 --- a/tests/baselines/reference/declFileExportImportChain.js +++ b/tests/baselines/reference/declFileExportImportChain.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileExportImportChain.ts] //// //// [declFileExportImportChain_a.ts] - module m1 { export module m2 { export class c1 { diff --git a/tests/baselines/reference/declFileExportImportChain.symbols b/tests/baselines/reference/declFileExportImportChain.symbols index 6e59fa2c167e9..364ccf28234b0 100644 --- a/tests/baselines/reference/declFileExportImportChain.symbols +++ b/tests/baselines/reference/declFileExportImportChain.symbols @@ -7,19 +7,18 @@ export var x: c.b1.a.m2.c1; >c : Symbol(c, Decl(declFileExportImportChain_d.ts, 0, 0)) >b1 : Symbol(c.b1, Decl(declFileExportImportChain_c.ts, 0, 0)) >a : Symbol(c.b1.a, Decl(declFileExportImportChain_b.ts, 0, 0)) ->m2 : Symbol(c.b1.a.m2, Decl(declFileExportImportChain_a.ts, 1, 11)) ->c1 : Symbol(c.b1.a.m2.c1, Decl(declFileExportImportChain_a.ts, 2, 22)) +>m2 : Symbol(c.b1.a.m2, Decl(declFileExportImportChain_a.ts, 0, 11)) +>c1 : Symbol(c.b1.a.m2.c1, Decl(declFileExportImportChain_a.ts, 1, 22)) === tests/cases/compiler/declFileExportImportChain_a.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileExportImportChain_a.ts, 0, 0)) export module m2 { ->m2 : Symbol(m2, Decl(declFileExportImportChain_a.ts, 1, 11)) +>m2 : Symbol(m2, Decl(declFileExportImportChain_a.ts, 0, 11)) export class c1 { ->c1 : Symbol(c1, Decl(declFileExportImportChain_a.ts, 2, 22)) +>c1 : Symbol(c1, Decl(declFileExportImportChain_a.ts, 1, 22)) } } } diff --git a/tests/baselines/reference/declFileExportImportChain.types b/tests/baselines/reference/declFileExportImportChain.types index f9601adb14706..e89a8974f1348 100644 --- a/tests/baselines/reference/declFileExportImportChain.types +++ b/tests/baselines/reference/declFileExportImportChain.types @@ -11,7 +11,6 @@ export var x: c.b1.a.m2.c1; >c1 : c.b1.a.m2.c1 === tests/cases/compiler/declFileExportImportChain_a.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileExportImportChain2.js b/tests/baselines/reference/declFileExportImportChain2.js index 70478fdf43028..ec7629ebed13b 100644 --- a/tests/baselines/reference/declFileExportImportChain2.js +++ b/tests/baselines/reference/declFileExportImportChain2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileExportImportChain2.ts] //// //// [declFileExportImportChain2_a.ts] - module m1 { export module m2 { export class c1 { diff --git a/tests/baselines/reference/declFileExportImportChain2.symbols b/tests/baselines/reference/declFileExportImportChain2.symbols index e5a80c87f9e03..0543bcbcbb8da 100644 --- a/tests/baselines/reference/declFileExportImportChain2.symbols +++ b/tests/baselines/reference/declFileExportImportChain2.symbols @@ -6,19 +6,18 @@ export var x: c.b.m2.c1; >x : Symbol(x, Decl(declFileExportImportChain2_d.ts, 1, 10)) >c : Symbol(c, Decl(declFileExportImportChain2_d.ts, 0, 0)) >b : Symbol(c.b, Decl(declFileExportImportChain2_c.ts, 0, 0)) ->m2 : Symbol(c.b.m2, Decl(declFileExportImportChain2_a.ts, 1, 11)) ->c1 : Symbol(c.b.m2.c1, Decl(declFileExportImportChain2_a.ts, 2, 22)) +>m2 : Symbol(c.b.m2, Decl(declFileExportImportChain2_a.ts, 0, 11)) +>c1 : Symbol(c.b.m2.c1, Decl(declFileExportImportChain2_a.ts, 1, 22)) === tests/cases/compiler/declFileExportImportChain2_a.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileExportImportChain2_a.ts, 0, 0)) export module m2 { ->m2 : Symbol(m2, Decl(declFileExportImportChain2_a.ts, 1, 11)) +>m2 : Symbol(m2, Decl(declFileExportImportChain2_a.ts, 0, 11)) export class c1 { ->c1 : Symbol(c1, Decl(declFileExportImportChain2_a.ts, 2, 22)) +>c1 : Symbol(c1, Decl(declFileExportImportChain2_a.ts, 1, 22)) } } } diff --git a/tests/baselines/reference/declFileExportImportChain2.types b/tests/baselines/reference/declFileExportImportChain2.types index 9c58318040415..c2978359074cb 100644 --- a/tests/baselines/reference/declFileExportImportChain2.types +++ b/tests/baselines/reference/declFileExportImportChain2.types @@ -10,7 +10,6 @@ export var x: c.b.m2.c1; >c1 : c.b.m2.c1 === tests/cases/compiler/declFileExportImportChain2_a.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.js b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.js index dda944bef3d77..a1d9f87d48358 100644 --- a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.js +++ b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.js @@ -1,5 +1,4 @@ //// [declFileForClassWithMultipleBaseClasses.ts] - class A { foo() { } } diff --git a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.symbols b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.symbols index 92c82d6ed4173..9da0b9a5c8548 100644 --- a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.symbols +++ b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.symbols @@ -1,54 +1,53 @@ === tests/cases/compiler/declFileForClassWithMultipleBaseClasses.ts === - class A { >A : Symbol(A, Decl(declFileForClassWithMultipleBaseClasses.ts, 0, 0)) foo() { } ->foo : Symbol(A.foo, Decl(declFileForClassWithMultipleBaseClasses.ts, 1, 9)) +>foo : Symbol(A.foo, Decl(declFileForClassWithMultipleBaseClasses.ts, 0, 9)) } class B { ->B : Symbol(B, Decl(declFileForClassWithMultipleBaseClasses.ts, 3, 1)) +>B : Symbol(B, Decl(declFileForClassWithMultipleBaseClasses.ts, 2, 1)) bar() { } ->bar : Symbol(B.bar, Decl(declFileForClassWithMultipleBaseClasses.ts, 5, 9)) +>bar : Symbol(B.bar, Decl(declFileForClassWithMultipleBaseClasses.ts, 4, 9)) } interface I { ->I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 7, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 23, 1)) +>I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 6, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 22, 1)) baz(); ->baz : Symbol(I.baz, Decl(declFileForClassWithMultipleBaseClasses.ts, 9, 13)) +>baz : Symbol(I.baz, Decl(declFileForClassWithMultipleBaseClasses.ts, 8, 13)) } interface J { ->J : Symbol(J, Decl(declFileForClassWithMultipleBaseClasses.ts, 11, 1)) +>J : Symbol(J, Decl(declFileForClassWithMultipleBaseClasses.ts, 10, 1)) bat(); ->bat : Symbol(J.bat, Decl(declFileForClassWithMultipleBaseClasses.ts, 13, 13)) +>bat : Symbol(J.bat, Decl(declFileForClassWithMultipleBaseClasses.ts, 12, 13)) } class D implements I, J { ->D : Symbol(D, Decl(declFileForClassWithMultipleBaseClasses.ts, 15, 1)) ->I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 7, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 23, 1)) ->J : Symbol(J, Decl(declFileForClassWithMultipleBaseClasses.ts, 11, 1)) +>D : Symbol(D, Decl(declFileForClassWithMultipleBaseClasses.ts, 14, 1)) +>I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 6, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 22, 1)) +>J : Symbol(J, Decl(declFileForClassWithMultipleBaseClasses.ts, 10, 1)) baz() { } ->baz : Symbol(D.baz, Decl(declFileForClassWithMultipleBaseClasses.ts, 18, 25)) +>baz : Symbol(D.baz, Decl(declFileForClassWithMultipleBaseClasses.ts, 17, 25)) bat() { } ->bat : Symbol(D.bat, Decl(declFileForClassWithMultipleBaseClasses.ts, 19, 13)) +>bat : Symbol(D.bat, Decl(declFileForClassWithMultipleBaseClasses.ts, 18, 13)) foo() { } ->foo : Symbol(D.foo, Decl(declFileForClassWithMultipleBaseClasses.ts, 20, 13)) +>foo : Symbol(D.foo, Decl(declFileForClassWithMultipleBaseClasses.ts, 19, 13)) bar() { } ->bar : Symbol(D.bar, Decl(declFileForClassWithMultipleBaseClasses.ts, 21, 13)) +>bar : Symbol(D.bar, Decl(declFileForClassWithMultipleBaseClasses.ts, 20, 13)) } interface I extends A, B { ->I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 7, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 23, 1)) +>I : Symbol(I, Decl(declFileForClassWithMultipleBaseClasses.ts, 6, 1), Decl(declFileForClassWithMultipleBaseClasses.ts, 22, 1)) >A : Symbol(A, Decl(declFileForClassWithMultipleBaseClasses.ts, 0, 0)) ->B : Symbol(B, Decl(declFileForClassWithMultipleBaseClasses.ts, 3, 1)) +>B : Symbol(B, Decl(declFileForClassWithMultipleBaseClasses.ts, 2, 1)) } diff --git a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.types b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.types index 0f7861d8b8ee6..b2438e131598f 100644 --- a/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.types +++ b/tests/baselines/reference/declFileForClassWithMultipleBaseClasses.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForClassWithMultipleBaseClasses.ts === - class A { >A : A diff --git a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.js b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.js index 2c0e89fe6dbd1..cff015a8b29d0 100644 --- a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.js +++ b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.js @@ -1,5 +1,4 @@ //// [declFileForClassWithPrivateOverloadedFunction.ts] - class C { private foo(x: number); private foo(x: string); diff --git a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.symbols b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.symbols index 69bf3db2cb37c..e0aff6e6c46ae 100644 --- a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.symbols +++ b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/declFileForClassWithPrivateOverloadedFunction.ts === - class C { >C : Symbol(C, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 0, 0)) private foo(x: number); ->foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 27)) ->x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 16)) +>foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 0, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27)) +>x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 16)) private foo(x: string); ->foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 27)) ->x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 16)) +>foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 0, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27)) +>x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 16)) private foo(x: any) { } ->foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 27)) ->x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 4, 16)) +>foo : Symbol(C.foo, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 0, 9), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 1, 27), Decl(declFileForClassWithPrivateOverloadedFunction.ts, 2, 27)) +>x : Symbol(x, Decl(declFileForClassWithPrivateOverloadedFunction.ts, 3, 16)) } diff --git a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.types b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.types index efdfde4574cb2..4e0197be90327 100644 --- a/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.types +++ b/tests/baselines/reference/declFileForClassWithPrivateOverloadedFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForClassWithPrivateOverloadedFunction.ts === - class C { >C : C diff --git a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.js b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.js index 9bdd0fc09a788..e97ee76d51059 100644 --- a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.js +++ b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.js @@ -1,5 +1,4 @@ //// [declFileForFunctionTypeAsTypeParameter.ts] - class X { } class C extends X<() => number> { diff --git a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.symbols b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.symbols index 329363ec36453..f153fef40a01e 100644 --- a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.symbols +++ b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/declFileForFunctionTypeAsTypeParameter.ts === - class X { >X : Symbol(X, Decl(declFileForFunctionTypeAsTypeParameter.ts, 0, 0)) ->T : Symbol(T, Decl(declFileForFunctionTypeAsTypeParameter.ts, 1, 8)) +>T : Symbol(T, Decl(declFileForFunctionTypeAsTypeParameter.ts, 0, 8)) } class C extends X<() => number> { ->C : Symbol(C, Decl(declFileForFunctionTypeAsTypeParameter.ts, 2, 1)) +>C : Symbol(C, Decl(declFileForFunctionTypeAsTypeParameter.ts, 1, 1)) >X : Symbol(X, Decl(declFileForFunctionTypeAsTypeParameter.ts, 0, 0)) } interface I extends X<() => number> { ->I : Symbol(I, Decl(declFileForFunctionTypeAsTypeParameter.ts, 4, 1)) +>I : Symbol(I, Decl(declFileForFunctionTypeAsTypeParameter.ts, 3, 1)) >X : Symbol(X, Decl(declFileForFunctionTypeAsTypeParameter.ts, 0, 0)) } diff --git a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types index ba203e39aab7a..2bd1c039bf79c 100644 --- a/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types +++ b/tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForFunctionTypeAsTypeParameter.ts === - class X { >X : X >T : T diff --git a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.js b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.js index 6010e632966df..4412c4a925bbb 100644 --- a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.js +++ b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.js @@ -1,5 +1,4 @@ //// [declFileForInterfaceWithOptionalFunction.ts] - interface I { foo? (x?); foo2? (x?: number): number; diff --git a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.symbols b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.symbols index a6a3e272c94ff..d434c9d08a1bc 100644 --- a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.symbols +++ b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/declFileForInterfaceWithOptionalFunction.ts === - interface I { >I : Symbol(I, Decl(declFileForInterfaceWithOptionalFunction.ts, 0, 0)) foo? (x?); ->foo : Symbol(I.foo, Decl(declFileForInterfaceWithOptionalFunction.ts, 1, 13)) ->x : Symbol(x, Decl(declFileForInterfaceWithOptionalFunction.ts, 2, 10)) +>foo : Symbol(I.foo, Decl(declFileForInterfaceWithOptionalFunction.ts, 0, 13)) +>x : Symbol(x, Decl(declFileForInterfaceWithOptionalFunction.ts, 1, 10)) foo2? (x?: number): number; ->foo2 : Symbol(I.foo2, Decl(declFileForInterfaceWithOptionalFunction.ts, 2, 14)) ->x : Symbol(x, Decl(declFileForInterfaceWithOptionalFunction.ts, 3, 11)) +>foo2 : Symbol(I.foo2, Decl(declFileForInterfaceWithOptionalFunction.ts, 1, 14)) +>x : Symbol(x, Decl(declFileForInterfaceWithOptionalFunction.ts, 2, 11)) } diff --git a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.types b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.types index fab33c939cf22..e653802dd75f4 100644 --- a/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.types +++ b/tests/baselines/reference/declFileForInterfaceWithOptionalFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForInterfaceWithOptionalFunction.ts === - interface I { >I : I diff --git a/tests/baselines/reference/declFileForInterfaceWithRestParams.js b/tests/baselines/reference/declFileForInterfaceWithRestParams.js index 8979f7df6dab7..2bc78db70036a 100644 --- a/tests/baselines/reference/declFileForInterfaceWithRestParams.js +++ b/tests/baselines/reference/declFileForInterfaceWithRestParams.js @@ -1,5 +1,4 @@ //// [declFileForInterfaceWithRestParams.ts] - interface I { foo(...x): typeof x; foo2(a: number, ...x): typeof x; diff --git a/tests/baselines/reference/declFileForInterfaceWithRestParams.symbols b/tests/baselines/reference/declFileForInterfaceWithRestParams.symbols index bccb096eb6c99..c820a7baa83c9 100644 --- a/tests/baselines/reference/declFileForInterfaceWithRestParams.symbols +++ b/tests/baselines/reference/declFileForInterfaceWithRestParams.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/declFileForInterfaceWithRestParams.ts === - interface I { >I : Symbol(I, Decl(declFileForInterfaceWithRestParams.ts, 0, 0)) foo(...x): typeof x; ->foo : Symbol(I.foo, Decl(declFileForInterfaceWithRestParams.ts, 1, 13)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 2, 8)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 2, 8)) +>foo : Symbol(I.foo, Decl(declFileForInterfaceWithRestParams.ts, 0, 13)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 1, 8)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 1, 8)) foo2(a: number, ...x): typeof x; ->foo2 : Symbol(I.foo2, Decl(declFileForInterfaceWithRestParams.ts, 2, 24)) ->a : Symbol(a, Decl(declFileForInterfaceWithRestParams.ts, 3, 9)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 3, 19)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 3, 19)) +>foo2 : Symbol(I.foo2, Decl(declFileForInterfaceWithRestParams.ts, 1, 24)) +>a : Symbol(a, Decl(declFileForInterfaceWithRestParams.ts, 2, 9)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 2, 19)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 2, 19)) foo3(b: string, ...x: string[]): typeof x; ->foo3 : Symbol(I.foo3, Decl(declFileForInterfaceWithRestParams.ts, 3, 36)) ->b : Symbol(b, Decl(declFileForInterfaceWithRestParams.ts, 4, 9)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 4, 19)) ->x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 4, 19)) +>foo3 : Symbol(I.foo3, Decl(declFileForInterfaceWithRestParams.ts, 2, 36)) +>b : Symbol(b, Decl(declFileForInterfaceWithRestParams.ts, 3, 9)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 3, 19)) +>x : Symbol(x, Decl(declFileForInterfaceWithRestParams.ts, 3, 19)) } diff --git a/tests/baselines/reference/declFileForInterfaceWithRestParams.types b/tests/baselines/reference/declFileForInterfaceWithRestParams.types index 817e118fb6c2c..7ea4eb598f5d0 100644 --- a/tests/baselines/reference/declFileForInterfaceWithRestParams.types +++ b/tests/baselines/reference/declFileForInterfaceWithRestParams.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForInterfaceWithRestParams.ts === - interface I { >I : I diff --git a/tests/baselines/reference/declFileForTypeParameters.js b/tests/baselines/reference/declFileForTypeParameters.js index 3fbac683ef904..4000e6301eb68 100644 --- a/tests/baselines/reference/declFileForTypeParameters.js +++ b/tests/baselines/reference/declFileForTypeParameters.js @@ -1,5 +1,4 @@ //// [declFileForTypeParameters.ts] - class C { x: T; foo(a: T): T { diff --git a/tests/baselines/reference/declFileForTypeParameters.symbols b/tests/baselines/reference/declFileForTypeParameters.symbols index 8838c3cdd05b0..626421881c259 100644 --- a/tests/baselines/reference/declFileForTypeParameters.symbols +++ b/tests/baselines/reference/declFileForTypeParameters.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/declFileForTypeParameters.ts === - class C { >C : Symbol(C, Decl(declFileForTypeParameters.ts, 0, 0)) ->T : Symbol(T, Decl(declFileForTypeParameters.ts, 1, 8)) +>T : Symbol(T, Decl(declFileForTypeParameters.ts, 0, 8)) x: T; ->x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 1, 12)) ->T : Symbol(T, Decl(declFileForTypeParameters.ts, 1, 8)) +>x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 0, 12)) +>T : Symbol(T, Decl(declFileForTypeParameters.ts, 0, 8)) foo(a: T): T { ->foo : Symbol(C.foo, Decl(declFileForTypeParameters.ts, 2, 9)) ->a : Symbol(a, Decl(declFileForTypeParameters.ts, 3, 8)) ->T : Symbol(T, Decl(declFileForTypeParameters.ts, 1, 8)) ->T : Symbol(T, Decl(declFileForTypeParameters.ts, 1, 8)) +>foo : Symbol(C.foo, Decl(declFileForTypeParameters.ts, 1, 9)) +>a : Symbol(a, Decl(declFileForTypeParameters.ts, 2, 8)) +>T : Symbol(T, Decl(declFileForTypeParameters.ts, 0, 8)) +>T : Symbol(T, Decl(declFileForTypeParameters.ts, 0, 8)) return this.x; ->this.x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 1, 12)) +>this.x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 0, 12)) >this : Symbol(C, Decl(declFileForTypeParameters.ts, 0, 0)) ->x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 1, 12)) +>x : Symbol(C.x, Decl(declFileForTypeParameters.ts, 0, 12)) } } diff --git a/tests/baselines/reference/declFileForTypeParameters.types b/tests/baselines/reference/declFileForTypeParameters.types index fe69da2cd0f66..e0cb47d837540 100644 --- a/tests/baselines/reference/declFileForTypeParameters.types +++ b/tests/baselines/reference/declFileForTypeParameters.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForTypeParameters.ts === - class C { >C : C >T : T diff --git a/tests/baselines/reference/declFileForVarList.js b/tests/baselines/reference/declFileForVarList.js index bb481017e3eae..0ccd51d2f71dc 100644 --- a/tests/baselines/reference/declFileForVarList.js +++ b/tests/baselines/reference/declFileForVarList.js @@ -1,5 +1,4 @@ //// [declFileForVarList.ts] - var x, y, z = 1; var x1 = 1, y2 = 2, z2 = 3; diff --git a/tests/baselines/reference/declFileForVarList.symbols b/tests/baselines/reference/declFileForVarList.symbols index 9e2fdd3ac6bb1..1e6e14927b2ab 100644 --- a/tests/baselines/reference/declFileForVarList.symbols +++ b/tests/baselines/reference/declFileForVarList.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/declFileForVarList.ts === - var x, y, z = 1; ->x : Symbol(x, Decl(declFileForVarList.ts, 1, 3)) ->y : Symbol(y, Decl(declFileForVarList.ts, 1, 6)) ->z : Symbol(z, Decl(declFileForVarList.ts, 1, 9)) +>x : Symbol(x, Decl(declFileForVarList.ts, 0, 3)) +>y : Symbol(y, Decl(declFileForVarList.ts, 0, 6)) +>z : Symbol(z, Decl(declFileForVarList.ts, 0, 9)) var x1 = 1, y2 = 2, z2 = 3; ->x1 : Symbol(x1, Decl(declFileForVarList.ts, 2, 3)) ->y2 : Symbol(y2, Decl(declFileForVarList.ts, 2, 11)) ->z2 : Symbol(z2, Decl(declFileForVarList.ts, 2, 19)) +>x1 : Symbol(x1, Decl(declFileForVarList.ts, 1, 3)) +>y2 : Symbol(y2, Decl(declFileForVarList.ts, 1, 11)) +>z2 : Symbol(z2, Decl(declFileForVarList.ts, 1, 19)) diff --git a/tests/baselines/reference/declFileForVarList.types b/tests/baselines/reference/declFileForVarList.types index d4c401d238343..89514b6576cd4 100644 --- a/tests/baselines/reference/declFileForVarList.types +++ b/tests/baselines/reference/declFileForVarList.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileForVarList.ts === - var x, y, z = 1; >x : any >y : any diff --git a/tests/baselines/reference/declFileFunctions.js b/tests/baselines/reference/declFileFunctions.js index f62b7772b41ae..68ac66200a6dc 100644 --- a/tests/baselines/reference/declFileFunctions.js +++ b/tests/baselines/reference/declFileFunctions.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileFunctions.ts] //// //// [declFileFunctions_0.ts] - /** This comment should appear for foo*/ export function foo() { } diff --git a/tests/baselines/reference/declFileFunctions.symbols b/tests/baselines/reference/declFileFunctions.symbols index 9ee1a3603bdea..6ec16c3399ec2 100644 --- a/tests/baselines/reference/declFileFunctions.symbols +++ b/tests/baselines/reference/declFileFunctions.symbols @@ -1,139 +1,138 @@ === tests/cases/compiler/declFileFunctions_0.ts === - /** This comment should appear for foo*/ export function foo() { >foo : Symbol(foo, Decl(declFileFunctions_0.ts, 0, 0)) } /** This is comment for function signature*/ export function fooWithParameters(/** this is comment about a*/a: string, ->fooWithParameters : Symbol(fooWithParameters, Decl(declFileFunctions_0.ts, 3, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 5, 34)) +>fooWithParameters : Symbol(fooWithParameters, Decl(declFileFunctions_0.ts, 2, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 4, 34)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileFunctions_0.ts, 5, 73)) +>b : Symbol(b, Decl(declFileFunctions_0.ts, 4, 73)) var d = a; ->d : Symbol(d, Decl(declFileFunctions_0.ts, 8, 7)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 5, 34)) +>d : Symbol(d, Decl(declFileFunctions_0.ts, 7, 7)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 4, 34)) } export function fooWithRestParameters(a: string, ...rests: string[]) { ->fooWithRestParameters : Symbol(fooWithRestParameters, Decl(declFileFunctions_0.ts, 9, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 10, 38)) ->rests : Symbol(rests, Decl(declFileFunctions_0.ts, 10, 48)) +>fooWithRestParameters : Symbol(fooWithRestParameters, Decl(declFileFunctions_0.ts, 8, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 9, 38)) +>rests : Symbol(rests, Decl(declFileFunctions_0.ts, 9, 48)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileFunctions_0.ts, 10, 38)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 9, 38)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileFunctions_0.ts, 10, 48)) +>rests : Symbol(rests, Decl(declFileFunctions_0.ts, 9, 48)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } export function fooWithOverloads(a: string): string; ->fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 12, 1), Decl(declFileFunctions_0.ts, 14, 52), Decl(declFileFunctions_0.ts, 15, 52)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 14, 33)) +>fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 11, 1), Decl(declFileFunctions_0.ts, 13, 52), Decl(declFileFunctions_0.ts, 14, 52)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 13, 33)) export function fooWithOverloads(a: number): number; ->fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 12, 1), Decl(declFileFunctions_0.ts, 14, 52), Decl(declFileFunctions_0.ts, 15, 52)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 15, 33)) +>fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 11, 1), Decl(declFileFunctions_0.ts, 13, 52), Decl(declFileFunctions_0.ts, 14, 52)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 14, 33)) export function fooWithOverloads(a: any): any { ->fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 12, 1), Decl(declFileFunctions_0.ts, 14, 52), Decl(declFileFunctions_0.ts, 15, 52)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 16, 33)) +>fooWithOverloads : Symbol(fooWithOverloads, Decl(declFileFunctions_0.ts, 11, 1), Decl(declFileFunctions_0.ts, 13, 52), Decl(declFileFunctions_0.ts, 14, 52)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 15, 33)) return a; ->a : Symbol(a, Decl(declFileFunctions_0.ts, 16, 33)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 15, 33)) } export function fooWithSingleOverload(a: string): string; ->fooWithSingleOverload : Symbol(fooWithSingleOverload, Decl(declFileFunctions_0.ts, 18, 1), Decl(declFileFunctions_0.ts, 20, 57)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 20, 38)) +>fooWithSingleOverload : Symbol(fooWithSingleOverload, Decl(declFileFunctions_0.ts, 17, 1), Decl(declFileFunctions_0.ts, 19, 57)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 19, 38)) export function fooWithSingleOverload(a: any) { ->fooWithSingleOverload : Symbol(fooWithSingleOverload, Decl(declFileFunctions_0.ts, 18, 1), Decl(declFileFunctions_0.ts, 20, 57)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 21, 38)) +>fooWithSingleOverload : Symbol(fooWithSingleOverload, Decl(declFileFunctions_0.ts, 17, 1), Decl(declFileFunctions_0.ts, 19, 57)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 20, 38)) return a; ->a : Symbol(a, Decl(declFileFunctions_0.ts, 21, 38)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 20, 38)) } export function fooWithTypePredicate(a: any): a is number { ->fooWithTypePredicate : Symbol(fooWithTypePredicate, Decl(declFileFunctions_0.ts, 23, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 25, 37)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 25, 37)) +>fooWithTypePredicate : Symbol(fooWithTypePredicate, Decl(declFileFunctions_0.ts, 22, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 24, 37)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 24, 37)) return true; } export function fooWithTypePredicateAndMulitpleParams(a: any, b: any, c: any): a is number { ->fooWithTypePredicateAndMulitpleParams : Symbol(fooWithTypePredicateAndMulitpleParams, Decl(declFileFunctions_0.ts, 27, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 28, 54)) ->b : Symbol(b, Decl(declFileFunctions_0.ts, 28, 61)) ->c : Symbol(c, Decl(declFileFunctions_0.ts, 28, 69)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 28, 54)) +>fooWithTypePredicateAndMulitpleParams : Symbol(fooWithTypePredicateAndMulitpleParams, Decl(declFileFunctions_0.ts, 26, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 27, 54)) +>b : Symbol(b, Decl(declFileFunctions_0.ts, 27, 61)) +>c : Symbol(c, Decl(declFileFunctions_0.ts, 27, 69)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 27, 54)) return true; } export function fooWithTypeTypePredicateAndGeneric(a: any): a is T { ->fooWithTypeTypePredicateAndGeneric : Symbol(fooWithTypeTypePredicateAndGeneric, Decl(declFileFunctions_0.ts, 30, 1)) ->T : Symbol(T, Decl(declFileFunctions_0.ts, 31, 51)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 31, 54)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 31, 54)) ->T : Symbol(T, Decl(declFileFunctions_0.ts, 31, 51)) +>fooWithTypeTypePredicateAndGeneric : Symbol(fooWithTypeTypePredicateAndGeneric, Decl(declFileFunctions_0.ts, 29, 1)) +>T : Symbol(T, Decl(declFileFunctions_0.ts, 30, 51)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 30, 54)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 30, 54)) +>T : Symbol(T, Decl(declFileFunctions_0.ts, 30, 51)) return true; } export function fooWithTypeTypePredicateAndRestParam(a: any, ...rest): a is number { ->fooWithTypeTypePredicateAndRestParam : Symbol(fooWithTypeTypePredicateAndRestParam, Decl(declFileFunctions_0.ts, 33, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 34, 53)) ->rest : Symbol(rest, Decl(declFileFunctions_0.ts, 34, 60)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 34, 53)) +>fooWithTypeTypePredicateAndRestParam : Symbol(fooWithTypeTypePredicateAndRestParam, Decl(declFileFunctions_0.ts, 32, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 33, 53)) +>rest : Symbol(rest, Decl(declFileFunctions_0.ts, 33, 60)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 33, 53)) return true; } /** This comment should appear for nonExportedFoo*/ function nonExportedFoo() { ->nonExportedFoo : Symbol(nonExportedFoo, Decl(declFileFunctions_0.ts, 36, 1)) +>nonExportedFoo : Symbol(nonExportedFoo, Decl(declFileFunctions_0.ts, 35, 1)) } /** This is comment for function signature*/ function nonExportedFooWithParameters(/** this is comment about a*/a: string, ->nonExportedFooWithParameters : Symbol(nonExportedFooWithParameters, Decl(declFileFunctions_0.ts, 40, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 42, 38)) +>nonExportedFooWithParameters : Symbol(nonExportedFooWithParameters, Decl(declFileFunctions_0.ts, 39, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 41, 38)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileFunctions_0.ts, 42, 77)) +>b : Symbol(b, Decl(declFileFunctions_0.ts, 41, 77)) var d = a; ->d : Symbol(d, Decl(declFileFunctions_0.ts, 45, 7)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 42, 38)) +>d : Symbol(d, Decl(declFileFunctions_0.ts, 44, 7)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 41, 38)) } function nonExportedFooWithRestParameters(a: string, ...rests: string[]) { ->nonExportedFooWithRestParameters : Symbol(nonExportedFooWithRestParameters, Decl(declFileFunctions_0.ts, 46, 1)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 47, 42)) ->rests : Symbol(rests, Decl(declFileFunctions_0.ts, 47, 52)) +>nonExportedFooWithRestParameters : Symbol(nonExportedFooWithRestParameters, Decl(declFileFunctions_0.ts, 45, 1)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 46, 42)) +>rests : Symbol(rests, Decl(declFileFunctions_0.ts, 46, 52)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileFunctions_0.ts, 47, 42)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 46, 42)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileFunctions_0.ts, 47, 52)) +>rests : Symbol(rests, Decl(declFileFunctions_0.ts, 46, 52)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } function nonExportedFooWithOverloads(a: string): string; ->nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 49, 1), Decl(declFileFunctions_0.ts, 51, 56), Decl(declFileFunctions_0.ts, 52, 56)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 51, 37)) +>nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 48, 1), Decl(declFileFunctions_0.ts, 50, 56), Decl(declFileFunctions_0.ts, 51, 56)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 50, 37)) function nonExportedFooWithOverloads(a: number): number; ->nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 49, 1), Decl(declFileFunctions_0.ts, 51, 56), Decl(declFileFunctions_0.ts, 52, 56)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 52, 37)) +>nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 48, 1), Decl(declFileFunctions_0.ts, 50, 56), Decl(declFileFunctions_0.ts, 51, 56)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 51, 37)) function nonExportedFooWithOverloads(a: any): any { ->nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 49, 1), Decl(declFileFunctions_0.ts, 51, 56), Decl(declFileFunctions_0.ts, 52, 56)) ->a : Symbol(a, Decl(declFileFunctions_0.ts, 53, 37)) +>nonExportedFooWithOverloads : Symbol(nonExportedFooWithOverloads, Decl(declFileFunctions_0.ts, 48, 1), Decl(declFileFunctions_0.ts, 50, 56), Decl(declFileFunctions_0.ts, 51, 56)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 52, 37)) return a; ->a : Symbol(a, Decl(declFileFunctions_0.ts, 53, 37)) +>a : Symbol(a, Decl(declFileFunctions_0.ts, 52, 37)) } === tests/cases/compiler/declFileFunctions_1.ts === diff --git a/tests/baselines/reference/declFileFunctions.types b/tests/baselines/reference/declFileFunctions.types index ee35577ce3ebc..c5bb89d38d39b 100644 --- a/tests/baselines/reference/declFileFunctions.types +++ b/tests/baselines/reference/declFileFunctions.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileFunctions_0.ts === - /** This comment should appear for foo*/ export function foo() { >foo : () => void diff --git a/tests/baselines/reference/declFileGenericType2.js b/tests/baselines/reference/declFileGenericType2.js index 1c6f2002da21c..5abf1a74a023a 100644 --- a/tests/baselines/reference/declFileGenericType2.js +++ b/tests/baselines/reference/declFileGenericType2.js @@ -1,5 +1,4 @@ //// [declFileGenericType2.ts] - declare module templa.mvc { interface IModel { } diff --git a/tests/baselines/reference/declFileGenericType2.symbols b/tests/baselines/reference/declFileGenericType2.symbols index 60ced2992d47d..43b61753a88b7 100644 --- a/tests/baselines/reference/declFileGenericType2.symbols +++ b/tests/baselines/reference/declFileGenericType2.symbols @@ -1,146 +1,145 @@ === tests/cases/compiler/declFileGenericType2.ts === - declare module templa.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) interface IModel { ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) } } declare module templa.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) interface IController { ->IController : Symbol(IController, Decl(declFileGenericType2.ts, 5, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 6, 26)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) +>IController : Symbol(IController, Decl(declFileGenericType2.ts, 4, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 5, 26)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) } } declare module templa.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) class AbstractController implements mvc.IController { ->AbstractController : Symbol(AbstractController, Decl(declFileGenericType2.ts, 9, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 10, 29)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) ->mvc.IController : Symbol(IController, Decl(declFileGenericType2.ts, 5, 27)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IController : Symbol(IController, Decl(declFileGenericType2.ts, 5, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 10, 29)) +>AbstractController : Symbol(AbstractController, Decl(declFileGenericType2.ts, 8, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 9, 29)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) +>mvc.IController : Symbol(IController, Decl(declFileGenericType2.ts, 4, 27)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IController : Symbol(IController, Decl(declFileGenericType2.ts, 4, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 9, 29)) } } declare module templa.mvc.composite { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->composite : Symbol(composite, Decl(declFileGenericType2.ts, 13, 26)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>composite : Symbol(composite, Decl(declFileGenericType2.ts, 12, 26)) interface ICompositeControllerModel extends mvc.IModel { ->ICompositeControllerModel : Symbol(ICompositeControllerModel, Decl(declFileGenericType2.ts, 13, 37)) ->mvc.IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) +>ICompositeControllerModel : Symbol(ICompositeControllerModel, Decl(declFileGenericType2.ts, 12, 37)) +>mvc.IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) getControllers(): mvc.IController[]; ->getControllers : Symbol(ICompositeControllerModel.getControllers, Decl(declFileGenericType2.ts, 14, 60)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IController : Symbol(IController, Decl(declFileGenericType2.ts, 5, 27)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 1, 27)) +>getControllers : Symbol(ICompositeControllerModel.getControllers, Decl(declFileGenericType2.ts, 13, 60)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IController : Symbol(IController, Decl(declFileGenericType2.ts, 4, 27)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(IModel, Decl(declFileGenericType2.ts, 0, 27)) } } module templa.dom.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) export interface IElementController extends templa.mvc.IController { ->IElementController : Symbol(IElementController, Decl(declFileGenericType2.ts, 18, 23)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 19, 40)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 1, 27)) ->templa.mvc.IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 5, 27)) ->templa.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 5, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 19, 40)) +>IElementController : Symbol(IElementController, Decl(declFileGenericType2.ts, 17, 23)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 18, 40)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 0, 27)) +>templa.mvc.IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 4, 27)) +>templa.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 4, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 18, 40)) } } // Module module templa.dom.mvc { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) export class AbstractElementController extends templa.mvc.AbstractController implements IElementController { ->AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 23, 23)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 25, 43)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 1, 27)) ->templa.mvc.AbstractController : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 9, 27)) ->templa.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->AbstractController : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 9, 27)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 25, 43)) ->IElementController : Symbol(IElementController, Decl(declFileGenericType2.ts, 18, 23)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 25, 43)) +>AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 22, 23)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 24, 43)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 0, 27)) +>templa.mvc.AbstractController : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 8, 27)) +>templa.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>AbstractController : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 8, 27)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 24, 43)) +>IElementController : Symbol(IElementController, Decl(declFileGenericType2.ts, 17, 23)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 24, 43)) constructor() { super(); ->super : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 9, 27)) +>super : Symbol(templa.mvc.AbstractController, Decl(declFileGenericType2.ts, 8, 27)) } } } // Module module templa.dom.mvc.composite { ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) ->composite : Symbol(composite, Decl(declFileGenericType2.ts, 32, 22)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) +>composite : Symbol(composite, Decl(declFileGenericType2.ts, 31, 22)) export class AbstractCompositeElementController extends templa.dom.mvc.AbstractElementController { ->AbstractCompositeElementController : Symbol(AbstractCompositeElementController, Decl(declFileGenericType2.ts, 32, 33)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 33, 52)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->composite : Symbol(templa.mvc.composite, Decl(declFileGenericType2.ts, 13, 26)) ->ICompositeControllerModel : Symbol(templa.mvc.composite.ICompositeControllerModel, Decl(declFileGenericType2.ts, 13, 37)) ->templa.dom.mvc.AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 23, 23)) ->templa.dom.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) ->templa.dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->dom : Symbol(dom, Decl(declFileGenericType2.ts, 18, 14), Decl(declFileGenericType2.ts, 23, 14), Decl(declFileGenericType2.ts, 32, 14)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 18, 18), Decl(declFileGenericType2.ts, 23, 18), Decl(declFileGenericType2.ts, 32, 18)) ->AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 23, 23)) ->ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 33, 52)) +>AbstractCompositeElementController : Symbol(AbstractCompositeElementController, Decl(declFileGenericType2.ts, 31, 33)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 32, 52)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>composite : Symbol(templa.mvc.composite, Decl(declFileGenericType2.ts, 12, 26)) +>ICompositeControllerModel : Symbol(templa.mvc.composite.ICompositeControllerModel, Decl(declFileGenericType2.ts, 12, 37)) +>templa.dom.mvc.AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 22, 23)) +>templa.dom.mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) +>templa.dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>dom : Symbol(dom, Decl(declFileGenericType2.ts, 17, 14), Decl(declFileGenericType2.ts, 22, 14), Decl(declFileGenericType2.ts, 31, 14)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 17, 18), Decl(declFileGenericType2.ts, 22, 18), Decl(declFileGenericType2.ts, 31, 18)) +>AbstractElementController : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 22, 23)) +>ModelType : Symbol(ModelType, Decl(declFileGenericType2.ts, 32, 52)) public _controllers: templa.mvc.IController[]; ->_controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 33, 179)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 5, 27)) ->templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 4, 1), Decl(declFileGenericType2.ts, 8, 1), Decl(declFileGenericType2.ts, 12, 1), Decl(declFileGenericType2.ts, 17, 1), Decl(declFileGenericType2.ts, 21, 1), Decl(declFileGenericType2.ts, 30, 1)) ->mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 1, 22), Decl(declFileGenericType2.ts, 5, 22), Decl(declFileGenericType2.ts, 9, 22), Decl(declFileGenericType2.ts, 13, 22)) ->IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 1, 27)) +>_controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 32, 179)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IController : Symbol(templa.mvc.IController, Decl(declFileGenericType2.ts, 4, 27)) +>templa : Symbol(templa, Decl(declFileGenericType2.ts, 0, 0), Decl(declFileGenericType2.ts, 3, 1), Decl(declFileGenericType2.ts, 7, 1), Decl(declFileGenericType2.ts, 11, 1), Decl(declFileGenericType2.ts, 16, 1), Decl(declFileGenericType2.ts, 20, 1), Decl(declFileGenericType2.ts, 29, 1)) +>mvc : Symbol(mvc, Decl(declFileGenericType2.ts, 0, 22), Decl(declFileGenericType2.ts, 4, 22), Decl(declFileGenericType2.ts, 8, 22), Decl(declFileGenericType2.ts, 12, 22)) +>IModel : Symbol(templa.mvc.IModel, Decl(declFileGenericType2.ts, 0, 27)) constructor() { super(); ->super : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 23, 23)) +>super : Symbol(AbstractElementController, Decl(declFileGenericType2.ts, 22, 23)) this._controllers = []; ->this._controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 33, 179)) ->this : Symbol(AbstractCompositeElementController, Decl(declFileGenericType2.ts, 32, 33)) ->_controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 33, 179)) +>this._controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 32, 179)) +>this : Symbol(AbstractCompositeElementController, Decl(declFileGenericType2.ts, 31, 33)) +>_controllers : Symbol(AbstractCompositeElementController._controllers, Decl(declFileGenericType2.ts, 32, 179)) } } } diff --git a/tests/baselines/reference/declFileGenericType2.types b/tests/baselines/reference/declFileGenericType2.types index c2a43db19214a..56e7dc2471aa5 100644 --- a/tests/baselines/reference/declFileGenericType2.types +++ b/tests/baselines/reference/declFileGenericType2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileGenericType2.ts === - declare module templa.mvc { >templa : typeof templa >mvc : typeof mvc diff --git a/tests/baselines/reference/declFileImportModuleWithExportAssignment.js b/tests/baselines/reference/declFileImportModuleWithExportAssignment.js index 110539774df5a..5215d3d1431a5 100644 --- a/tests/baselines/reference/declFileImportModuleWithExportAssignment.js +++ b/tests/baselines/reference/declFileImportModuleWithExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileImportModuleWithExportAssignment.ts] //// //// [declFileImportModuleWithExportAssignment_0.ts] - module m2 { export interface connectModule { (res, req, next): void; diff --git a/tests/baselines/reference/declFileImportModuleWithExportAssignment.symbols b/tests/baselines/reference/declFileImportModuleWithExportAssignment.symbols index 1681dfa27823a..eb08bd48a4c62 100644 --- a/tests/baselines/reference/declFileImportModuleWithExportAssignment.symbols +++ b/tests/baselines/reference/declFileImportModuleWithExportAssignment.symbols @@ -8,56 +8,55 @@ export var a = a1; >a1 : Symbol(a1, Decl(declFileImportModuleWithExportAssignment_1.ts, 0, 0)) a.test1(null, null, null); ->a.test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 12, 25)) +>a.test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 25)) >a : Symbol(a, Decl(declFileImportModuleWithExportAssignment_1.ts, 2, 10)) ->test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 12, 25)) +>test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 25)) === tests/cases/compiler/declFileImportModuleWithExportAssignment_0.ts === - module m2 { ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) export interface connectModule { ->connectModule : Symbol(connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 1, 11)) +>connectModule : Symbol(connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 11)) (res, req, next): void; ->res : Symbol(res, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 9)) ->req : Symbol(req, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 13)) ->next : Symbol(next, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 18)) +>res : Symbol(res, Decl(declFileImportModuleWithExportAssignment_0.ts, 2, 9)) +>req : Symbol(req, Decl(declFileImportModuleWithExportAssignment_0.ts, 2, 13)) +>next : Symbol(next, Decl(declFileImportModuleWithExportAssignment_0.ts, 2, 18)) } export interface connectExport { ->connectExport : Symbol(connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 4, 5)) +>connectExport : Symbol(connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 5)) use: (mod: connectModule) => connectExport; ->use : Symbol(connectExport.use, Decl(declFileImportModuleWithExportAssignment_0.ts, 5, 36)) ->mod : Symbol(mod, Decl(declFileImportModuleWithExportAssignment_0.ts, 6, 14)) ->connectModule : Symbol(connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 1, 11)) ->connectExport : Symbol(connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 4, 5)) +>use : Symbol(connectExport.use, Decl(declFileImportModuleWithExportAssignment_0.ts, 4, 36)) +>mod : Symbol(mod, Decl(declFileImportModuleWithExportAssignment_0.ts, 5, 14)) +>connectModule : Symbol(connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 11)) +>connectExport : Symbol(connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 5)) listen: (port: number) => void; ->listen : Symbol(connectExport.listen, Decl(declFileImportModuleWithExportAssignment_0.ts, 6, 51)) ->port : Symbol(port, Decl(declFileImportModuleWithExportAssignment_0.ts, 7, 17)) +>listen : Symbol(connectExport.listen, Decl(declFileImportModuleWithExportAssignment_0.ts, 5, 51)) +>port : Symbol(port, Decl(declFileImportModuleWithExportAssignment_0.ts, 6, 17)) } } var m2: { ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) (): m2.connectExport; ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) ->connectExport : Symbol(m2.connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 4, 5)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) +>connectExport : Symbol(m2.connectExport, Decl(declFileImportModuleWithExportAssignment_0.ts, 3, 5)) test1: m2.connectModule; ->test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 12, 25)) ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) ->connectModule : Symbol(m2.connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 1, 11)) +>test1 : Symbol(test1, Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 25)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) +>connectModule : Symbol(m2.connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 11)) test2(): m2.connectModule; ->test2 : Symbol(test2, Decl(declFileImportModuleWithExportAssignment_0.ts, 13, 28)) ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) ->connectModule : Symbol(m2.connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 1, 11)) +>test2 : Symbol(test2, Decl(declFileImportModuleWithExportAssignment_0.ts, 12, 28)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) +>connectModule : Symbol(m2.connectModule, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 11)) }; export = m2; ->m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 11, 3)) +>m2 : Symbol(m2, Decl(declFileImportModuleWithExportAssignment_0.ts, 0, 0), Decl(declFileImportModuleWithExportAssignment_0.ts, 10, 3)) diff --git a/tests/baselines/reference/declFileImportModuleWithExportAssignment.types b/tests/baselines/reference/declFileImportModuleWithExportAssignment.types index 123b7b56d4faf..a1bec1e3f5246 100644 --- a/tests/baselines/reference/declFileImportModuleWithExportAssignment.types +++ b/tests/baselines/reference/declFileImportModuleWithExportAssignment.types @@ -17,7 +17,6 @@ a.test1(null, null, null); >null : null === tests/cases/compiler/declFileImportModuleWithExportAssignment_0.ts === - module m2 { >m2 : { (): connectExport; test1: connectModule; test2(): connectModule; } diff --git a/tests/baselines/reference/declFileIndexSignatures.js b/tests/baselines/reference/declFileIndexSignatures.js index b7b2698b11b91..0282816e9d868 100644 --- a/tests/baselines/reference/declFileIndexSignatures.js +++ b/tests/baselines/reference/declFileIndexSignatures.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileIndexSignatures.ts] //// //// [declFileIndexSignatures_0.ts] - export interface IStringIndexSignature { [s: string]: string; } diff --git a/tests/baselines/reference/declFileIndexSignatures.symbols b/tests/baselines/reference/declFileIndexSignatures.symbols index e89cfc79b0dae..c04de687b03f9 100644 --- a/tests/baselines/reference/declFileIndexSignatures.symbols +++ b/tests/baselines/reference/declFileIndexSignatures.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/declFileIndexSignatures_0.ts === - export interface IStringIndexSignature { >IStringIndexSignature : Symbol(IStringIndexSignature, Decl(declFileIndexSignatures_0.ts, 0, 0)) [s: string]: string; ->s : Symbol(s, Decl(declFileIndexSignatures_0.ts, 2, 5)) +>s : Symbol(s, Decl(declFileIndexSignatures_0.ts, 1, 5)) } export interface INumberIndexSignature { ->INumberIndexSignature : Symbol(INumberIndexSignature, Decl(declFileIndexSignatures_0.ts, 3, 1)) +>INumberIndexSignature : Symbol(INumberIndexSignature, Decl(declFileIndexSignatures_0.ts, 2, 1)) [n: number]: number; ->n : Symbol(n, Decl(declFileIndexSignatures_0.ts, 5, 5)) +>n : Symbol(n, Decl(declFileIndexSignatures_0.ts, 4, 5)) } export interface IBothIndexSignature { ->IBothIndexSignature : Symbol(IBothIndexSignature, Decl(declFileIndexSignatures_0.ts, 6, 1)) +>IBothIndexSignature : Symbol(IBothIndexSignature, Decl(declFileIndexSignatures_0.ts, 5, 1)) [s: string]: any; ->s : Symbol(s, Decl(declFileIndexSignatures_0.ts, 9, 5)) +>s : Symbol(s, Decl(declFileIndexSignatures_0.ts, 8, 5)) [n: number]: number; ->n : Symbol(n, Decl(declFileIndexSignatures_0.ts, 10, 5)) +>n : Symbol(n, Decl(declFileIndexSignatures_0.ts, 9, 5)) } export interface IIndexSignatureWithTypeParameter { ->IIndexSignatureWithTypeParameter : Symbol(IIndexSignatureWithTypeParameter, Decl(declFileIndexSignatures_0.ts, 11, 1)) ->T : Symbol(T, Decl(declFileIndexSignatures_0.ts, 13, 50)) +>IIndexSignatureWithTypeParameter : Symbol(IIndexSignatureWithTypeParameter, Decl(declFileIndexSignatures_0.ts, 10, 1)) +>T : Symbol(T, Decl(declFileIndexSignatures_0.ts, 12, 50)) [a: string]: T; ->a : Symbol(a, Decl(declFileIndexSignatures_0.ts, 14, 5)) ->T : Symbol(T, Decl(declFileIndexSignatures_0.ts, 13, 50)) +>a : Symbol(a, Decl(declFileIndexSignatures_0.ts, 13, 5)) +>T : Symbol(T, Decl(declFileIndexSignatures_0.ts, 12, 50)) } === tests/cases/compiler/declFileIndexSignatures_1.ts === diff --git a/tests/baselines/reference/declFileIndexSignatures.types b/tests/baselines/reference/declFileIndexSignatures.types index c971fb4aeb0fe..28822a4bfd170 100644 --- a/tests/baselines/reference/declFileIndexSignatures.types +++ b/tests/baselines/reference/declFileIndexSignatures.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileIndexSignatures_0.ts === - export interface IStringIndexSignature { >IStringIndexSignature : IStringIndexSignature diff --git a/tests/baselines/reference/declFileMethods.js b/tests/baselines/reference/declFileMethods.js index 61e2bfab70015..cc6d796e5cfc8 100644 --- a/tests/baselines/reference/declFileMethods.js +++ b/tests/baselines/reference/declFileMethods.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileMethods.ts] //// //// [declFileMethods_0.ts] - export class c1 { /** This comment should appear for foo*/ public foo() { diff --git a/tests/baselines/reference/declFileMethods.symbols b/tests/baselines/reference/declFileMethods.symbols index 723065c62e435..4acf63eff08d5 100644 --- a/tests/baselines/reference/declFileMethods.symbols +++ b/tests/baselines/reference/declFileMethods.symbols @@ -1,217 +1,216 @@ === tests/cases/compiler/declFileMethods_0.ts === - export class c1 { >c1 : Symbol(c1, Decl(declFileMethods_0.ts, 0, 0)) /** This comment should appear for foo*/ public foo() { ->foo : Symbol(c1.foo, Decl(declFileMethods_0.ts, 1, 17)) +>foo : Symbol(c1.foo, Decl(declFileMethods_0.ts, 0, 17)) } /** This is comment for function signature*/ public fooWithParameters(/** this is comment about a*/a: string, ->fooWithParameters : Symbol(c1.fooWithParameters, Decl(declFileMethods_0.ts, 4, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 6, 29)) +>fooWithParameters : Symbol(c1.fooWithParameters, Decl(declFileMethods_0.ts, 3, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 5, 29)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileMethods_0.ts, 6, 68)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 5, 68)) var d = a; ->d : Symbol(d, Decl(declFileMethods_0.ts, 9, 11)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 6, 29)) +>d : Symbol(d, Decl(declFileMethods_0.ts, 8, 11)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 5, 29)) } public fooWithRestParameters(a: string, ...rests: string[]) { ->fooWithRestParameters : Symbol(c1.fooWithRestParameters, Decl(declFileMethods_0.ts, 10, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 11, 33)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 11, 43)) +>fooWithRestParameters : Symbol(c1.fooWithRestParameters, Decl(declFileMethods_0.ts, 9, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 10, 33)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 10, 43)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileMethods_0.ts, 11, 33)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 10, 33)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 11, 43)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 10, 43)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } public fooWithOverloads(a: string): string; ->fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 13, 5), Decl(declFileMethods_0.ts, 15, 47), Decl(declFileMethods_0.ts, 16, 47)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 15, 28)) +>fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 12, 5), Decl(declFileMethods_0.ts, 14, 47), Decl(declFileMethods_0.ts, 15, 47)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 14, 28)) public fooWithOverloads(a: number): number; ->fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 13, 5), Decl(declFileMethods_0.ts, 15, 47), Decl(declFileMethods_0.ts, 16, 47)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 16, 28)) +>fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 12, 5), Decl(declFileMethods_0.ts, 14, 47), Decl(declFileMethods_0.ts, 15, 47)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 15, 28)) public fooWithOverloads(a: any): any { ->fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 13, 5), Decl(declFileMethods_0.ts, 15, 47), Decl(declFileMethods_0.ts, 16, 47)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 17, 28)) +>fooWithOverloads : Symbol(c1.fooWithOverloads, Decl(declFileMethods_0.ts, 12, 5), Decl(declFileMethods_0.ts, 14, 47), Decl(declFileMethods_0.ts, 15, 47)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 16, 28)) return a; ->a : Symbol(a, Decl(declFileMethods_0.ts, 17, 28)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 16, 28)) } /** This comment should appear for privateFoo*/ private privateFoo() { ->privateFoo : Symbol(c1.privateFoo, Decl(declFileMethods_0.ts, 19, 5)) +>privateFoo : Symbol(c1.privateFoo, Decl(declFileMethods_0.ts, 18, 5)) } /** This is comment for function signature*/ private privateFooWithParameters(/** this is comment about a*/a: string, ->privateFooWithParameters : Symbol(c1.privateFooWithParameters, Decl(declFileMethods_0.ts, 24, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 26, 37)) +>privateFooWithParameters : Symbol(c1.privateFooWithParameters, Decl(declFileMethods_0.ts, 23, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 25, 37)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileMethods_0.ts, 26, 76)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 25, 76)) var d = a; ->d : Symbol(d, Decl(declFileMethods_0.ts, 29, 11)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 26, 37)) +>d : Symbol(d, Decl(declFileMethods_0.ts, 28, 11)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 25, 37)) } private privateFooWithRestParameters(a: string, ...rests: string[]) { ->privateFooWithRestParameters : Symbol(c1.privateFooWithRestParameters, Decl(declFileMethods_0.ts, 30, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 31, 41)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 31, 51)) +>privateFooWithRestParameters : Symbol(c1.privateFooWithRestParameters, Decl(declFileMethods_0.ts, 29, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 30, 41)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 30, 51)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileMethods_0.ts, 31, 41)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 30, 41)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 31, 51)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 30, 51)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } private privateFooWithOverloads(a: string): string; ->privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 34, 36)) +>privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 32, 5), Decl(declFileMethods_0.ts, 33, 55), Decl(declFileMethods_0.ts, 34, 55)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 33, 36)) private privateFooWithOverloads(a: number): number; ->privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 35, 36)) +>privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 32, 5), Decl(declFileMethods_0.ts, 33, 55), Decl(declFileMethods_0.ts, 34, 55)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 34, 36)) private privateFooWithOverloads(a: any): any { ->privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 36, 36)) +>privateFooWithOverloads : Symbol(c1.privateFooWithOverloads, Decl(declFileMethods_0.ts, 32, 5), Decl(declFileMethods_0.ts, 33, 55), Decl(declFileMethods_0.ts, 34, 55)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 35, 36)) return a; ->a : Symbol(a, Decl(declFileMethods_0.ts, 36, 36)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 35, 36)) } /** This comment should appear for static foo*/ static staticFoo() { ->staticFoo : Symbol(c1.staticFoo, Decl(declFileMethods_0.ts, 38, 5)) +>staticFoo : Symbol(c1.staticFoo, Decl(declFileMethods_0.ts, 37, 5)) } /** This is comment for function signature*/ static staticFooWithParameters(/** this is comment about a*/a: string, ->staticFooWithParameters : Symbol(c1.staticFooWithParameters, Decl(declFileMethods_0.ts, 43, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 45, 35)) +>staticFooWithParameters : Symbol(c1.staticFooWithParameters, Decl(declFileMethods_0.ts, 42, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 44, 35)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileMethods_0.ts, 45, 74)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 44, 74)) var d = a; ->d : Symbol(d, Decl(declFileMethods_0.ts, 48, 11)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 45, 35)) +>d : Symbol(d, Decl(declFileMethods_0.ts, 47, 11)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 44, 35)) } static staticFooWithRestParameters(a: string, ...rests: string[]) { ->staticFooWithRestParameters : Symbol(c1.staticFooWithRestParameters, Decl(declFileMethods_0.ts, 49, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 50, 39)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 50, 49)) +>staticFooWithRestParameters : Symbol(c1.staticFooWithRestParameters, Decl(declFileMethods_0.ts, 48, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 49, 39)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 49, 49)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileMethods_0.ts, 50, 39)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 49, 39)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 50, 49)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 49, 49)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } static staticFooWithOverloads(a: string): string; ->staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 53, 34)) +>staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 51, 5), Decl(declFileMethods_0.ts, 52, 53), Decl(declFileMethods_0.ts, 53, 53)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 52, 34)) static staticFooWithOverloads(a: number): number; ->staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 54, 34)) +>staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 51, 5), Decl(declFileMethods_0.ts, 52, 53), Decl(declFileMethods_0.ts, 53, 53)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 53, 34)) static staticFooWithOverloads(a: any): any { ->staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 55, 34)) +>staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 51, 5), Decl(declFileMethods_0.ts, 52, 53), Decl(declFileMethods_0.ts, 53, 53)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 54, 34)) return a; ->a : Symbol(a, Decl(declFileMethods_0.ts, 55, 34)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 54, 34)) } /** This comment should appear for privateStaticFoo*/ private static privateStaticFoo() { ->privateStaticFoo : Symbol(c1.privateStaticFoo, Decl(declFileMethods_0.ts, 57, 5)) +>privateStaticFoo : Symbol(c1.privateStaticFoo, Decl(declFileMethods_0.ts, 56, 5)) } /** This is comment for function signature*/ private static privateStaticFooWithParameters(/** this is comment about a*/a: string, ->privateStaticFooWithParameters : Symbol(c1.privateStaticFooWithParameters, Decl(declFileMethods_0.ts, 62, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 64, 50)) +>privateStaticFooWithParameters : Symbol(c1.privateStaticFooWithParameters, Decl(declFileMethods_0.ts, 61, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 63, 50)) /** this is comment for b*/ b: number) { ->b : Symbol(b, Decl(declFileMethods_0.ts, 64, 89)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 63, 89)) var d = a; ->d : Symbol(d, Decl(declFileMethods_0.ts, 67, 11)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 64, 50)) +>d : Symbol(d, Decl(declFileMethods_0.ts, 66, 11)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 63, 50)) } private static privateStaticFooWithRestParameters(a: string, ...rests: string[]) { ->privateStaticFooWithRestParameters : Symbol(c1.privateStaticFooWithRestParameters, Decl(declFileMethods_0.ts, 68, 5)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 69, 54)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 69, 64)) +>privateStaticFooWithRestParameters : Symbol(c1.privateStaticFooWithRestParameters, Decl(declFileMethods_0.ts, 67, 5)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 68, 54)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 68, 64)) return a + rests.join(""); ->a : Symbol(a, Decl(declFileMethods_0.ts, 69, 54)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 68, 54)) >rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 69, 64)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 68, 64)) >join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } private static privateStaticFooWithOverloads(a: string): string; ->privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 72, 49)) +>privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 70, 5), Decl(declFileMethods_0.ts, 71, 68), Decl(declFileMethods_0.ts, 72, 68)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 71, 49)) private static privateStaticFooWithOverloads(a: number): number; ->privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 73, 49)) +>privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 70, 5), Decl(declFileMethods_0.ts, 71, 68), Decl(declFileMethods_0.ts, 72, 68)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 72, 49)) private static privateStaticFooWithOverloads(a: any): any { ->privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 74, 49)) +>privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 70, 5), Decl(declFileMethods_0.ts, 71, 68), Decl(declFileMethods_0.ts, 72, 68)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 73, 49)) return a; ->a : Symbol(a, Decl(declFileMethods_0.ts, 74, 49)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 73, 49)) } } export interface I1 { ->I1 : Symbol(I1, Decl(declFileMethods_0.ts, 77, 1)) +>I1 : Symbol(I1, Decl(declFileMethods_0.ts, 76, 1)) /** This comment should appear for foo*/ foo(): string; ->foo : Symbol(I1.foo, Decl(declFileMethods_0.ts, 79, 21)) +>foo : Symbol(I1.foo, Decl(declFileMethods_0.ts, 78, 21)) /** This is comment for function signature*/ fooWithParameters(/** this is comment about a*/a: string, ->fooWithParameters : Symbol(I1.fooWithParameters, Decl(declFileMethods_0.ts, 81, 18)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 84, 22)) +>fooWithParameters : Symbol(I1.fooWithParameters, Decl(declFileMethods_0.ts, 80, 18)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 83, 22)) /** this is comment for b*/ b: number): void; ->b : Symbol(b, Decl(declFileMethods_0.ts, 84, 61)) +>b : Symbol(b, Decl(declFileMethods_0.ts, 83, 61)) fooWithRestParameters(a: string, ...rests: string[]): string; ->fooWithRestParameters : Symbol(I1.fooWithRestParameters, Decl(declFileMethods_0.ts, 86, 25)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 88, 26)) ->rests : Symbol(rests, Decl(declFileMethods_0.ts, 88, 36)) +>fooWithRestParameters : Symbol(I1.fooWithRestParameters, Decl(declFileMethods_0.ts, 85, 25)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 87, 26)) +>rests : Symbol(rests, Decl(declFileMethods_0.ts, 87, 36)) fooWithOverloads(a: string): string; ->fooWithOverloads : Symbol(I1.fooWithOverloads, Decl(declFileMethods_0.ts, 88, 65), Decl(declFileMethods_0.ts, 90, 40)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 90, 21)) +>fooWithOverloads : Symbol(I1.fooWithOverloads, Decl(declFileMethods_0.ts, 87, 65), Decl(declFileMethods_0.ts, 89, 40)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 89, 21)) fooWithOverloads(a: number): number; ->fooWithOverloads : Symbol(I1.fooWithOverloads, Decl(declFileMethods_0.ts, 88, 65), Decl(declFileMethods_0.ts, 90, 40)) ->a : Symbol(a, Decl(declFileMethods_0.ts, 91, 21)) +>fooWithOverloads : Symbol(I1.fooWithOverloads, Decl(declFileMethods_0.ts, 87, 65), Decl(declFileMethods_0.ts, 89, 40)) +>a : Symbol(a, Decl(declFileMethods_0.ts, 90, 21)) } === tests/cases/compiler/declFileMethods_1.ts === diff --git a/tests/baselines/reference/declFileMethods.types b/tests/baselines/reference/declFileMethods.types index 44c08117e9391..6c378a535937a 100644 --- a/tests/baselines/reference/declFileMethods.types +++ b/tests/baselines/reference/declFileMethods.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileMethods_0.ts === - export class c1 { >c1 : c1 diff --git a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.js b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.js index b2f27673c4d34..37c8f6a9999b4 100644 --- a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.js +++ b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.js @@ -1,5 +1,4 @@ //// [declFileModuleAssignmentInObjectLiteralProperty.ts] - module m1 { export class c { } diff --git a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols index b47f6faeb5072..fa063aae0d54e 100644 --- a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols +++ b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/declFileModuleAssignmentInObjectLiteralProperty.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0)) export class c { ->c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 1, 11)) +>c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 11)) } } var d = { ->d : Symbol(d, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 3)) +>d : Symbol(d, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 4, 3)) m1: { m: m1 }, ->m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 9)) ->m : Symbol(m, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 9)) +>m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 4, 9)) +>m : Symbol(m, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 9)) >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0)) m2: { c: m1.c }, ->m2 : Symbol(m2, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 18)) ->c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 7, 9)) ->m1.c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 1, 11)) +>m2 : Symbol(m2, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 18)) +>c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 9)) +>m1.c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 11)) >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0)) ->c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 1, 11)) +>c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 11)) }; diff --git a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.types b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.types index 6fd697b7ea2eb..5efb11159682f 100644 --- a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.types +++ b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileModuleAssignmentInObjectLiteralProperty.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.js b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.js index 6b6fe3eebe43a..1f1f2c78ff3bd 100644 --- a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.js +++ b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.js @@ -1,5 +1,4 @@ //// [declFileModuleWithPropertyOfTypeModule.ts] - module m { export class c { } diff --git a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.symbols b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.symbols index ee69745e8d3f2..21a03300725b4 100644 --- a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.symbols +++ b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/declFileModuleWithPropertyOfTypeModule.ts === - module m { >m : Symbol(m, Decl(declFileModuleWithPropertyOfTypeModule.ts, 0, 0)) export class c { ->c : Symbol(c, Decl(declFileModuleWithPropertyOfTypeModule.ts, 1, 10)) +>c : Symbol(c, Decl(declFileModuleWithPropertyOfTypeModule.ts, 0, 10)) } export var a = m; ->a : Symbol(a, Decl(declFileModuleWithPropertyOfTypeModule.ts, 5, 14)) +>a : Symbol(a, Decl(declFileModuleWithPropertyOfTypeModule.ts, 4, 14)) >m : Symbol(m, Decl(declFileModuleWithPropertyOfTypeModule.ts, 0, 0)) } diff --git a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.types b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.types index ecdc4396df459..2ae0e69cf018a 100644 --- a/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.types +++ b/tests/baselines/reference/declFileModuleWithPropertyOfTypeModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileModuleWithPropertyOfTypeModule.ts === - module m { >m : typeof m diff --git a/tests/baselines/reference/declFileObjectLiteralWithAccessors.js b/tests/baselines/reference/declFileObjectLiteralWithAccessors.js index 7886736f7e452..9c9f897e8b3b1 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithAccessors.js +++ b/tests/baselines/reference/declFileObjectLiteralWithAccessors.js @@ -1,5 +1,4 @@ //// [declFileObjectLiteralWithAccessors.ts] - function /*1*/makePoint(x: number) { return { b: 10, diff --git a/tests/baselines/reference/declFileObjectLiteralWithAccessors.symbols b/tests/baselines/reference/declFileObjectLiteralWithAccessors.symbols index 862b0b3781eff..a8d68d4254415 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithAccessors.symbols +++ b/tests/baselines/reference/declFileObjectLiteralWithAccessors.symbols @@ -1,36 +1,35 @@ === tests/cases/compiler/declFileObjectLiteralWithAccessors.ts === - function /*1*/makePoint(x: number) { >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithAccessors.ts, 0, 0)) ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 0, 24)) return { b: 10, ->b : Symbol(b, Decl(declFileObjectLiteralWithAccessors.ts, 2, 12)) +>b : Symbol(b, Decl(declFileObjectLiteralWithAccessors.ts, 1, 12)) get x() { return x; }, ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 0, 24)) set x(a: number) { this.b = a; } ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) ->a : Symbol(a, Decl(declFileObjectLiteralWithAccessors.ts, 5, 14)) ->a : Symbol(a, Decl(declFileObjectLiteralWithAccessors.ts, 5, 14)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) +>a : Symbol(a, Decl(declFileObjectLiteralWithAccessors.ts, 4, 14)) +>a : Symbol(a, Decl(declFileObjectLiteralWithAccessors.ts, 4, 14)) }; }; var /*4*/point = makePoint(2); ->point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 8, 3)) +>point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 7, 3)) >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithAccessors.ts, 0, 0)) var /*2*/x = point.x; ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 9, 3)) ->point.x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) ->point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 8, 3)) ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 8, 3)) +>point.x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) +>point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 7, 3)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) point./*3*/x = 30; ->point./*3*/x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) ->point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 8, 3)) ->x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 3, 14), Decl(declFileObjectLiteralWithAccessors.ts, 4, 30)) +>point./*3*/x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) +>point : Symbol(point, Decl(declFileObjectLiteralWithAccessors.ts, 7, 3)) +>x : Symbol(x, Decl(declFileObjectLiteralWithAccessors.ts, 2, 14), Decl(declFileObjectLiteralWithAccessors.ts, 3, 30)) diff --git a/tests/baselines/reference/declFileObjectLiteralWithAccessors.types b/tests/baselines/reference/declFileObjectLiteralWithAccessors.types index 389b88de565c7..d9357c3e0527a 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithAccessors.types +++ b/tests/baselines/reference/declFileObjectLiteralWithAccessors.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileObjectLiteralWithAccessors.ts === - function /*1*/makePoint(x: number) { >makePoint : (x: number) => { b: number; x: number; } >x : number diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.js b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.js index eb440c028d582..4d7f3fe7cfede 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.js +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.js @@ -1,5 +1,4 @@ //// [declFileObjectLiteralWithOnlyGetter.ts] - function /*1*/makePoint(x: number) { return { get x() { return x; }, diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.symbols b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.symbols index ef9cd96e5555c..abc17358cd7c8 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.symbols +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.symbols @@ -1,23 +1,22 @@ === tests/cases/compiler/declFileObjectLiteralWithOnlyGetter.ts === - function /*1*/makePoint(x: number) { >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithOnlyGetter.ts, 0, 0)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 0, 24)) return { get x() { return x; }, ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 2, 12)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 12)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 0, 24)) }; }; var /*4*/point = makePoint(2); ->point : Symbol(point, Decl(declFileObjectLiteralWithOnlyGetter.ts, 6, 3)) +>point : Symbol(point, Decl(declFileObjectLiteralWithOnlyGetter.ts, 5, 3)) >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithOnlyGetter.ts, 0, 0)) var /*2*/x = point./*3*/x; ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 7, 3)) ->point./*3*/x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 2, 12)) ->point : Symbol(point, Decl(declFileObjectLiteralWithOnlyGetter.ts, 6, 3)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 2, 12)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 6, 3)) +>point./*3*/x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 12)) +>point : Symbol(point, Decl(declFileObjectLiteralWithOnlyGetter.ts, 5, 3)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlyGetter.ts, 1, 12)) diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.types b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.types index c4e563f5a0367..dd1ee56815848 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.types +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlyGetter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileObjectLiteralWithOnlyGetter.ts === - function /*1*/makePoint(x: number) { >makePoint : (x: number) => { readonly x: number; } >x : number diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.js b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.js index f7a48fe810c45..188e47c8b8e50 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.js +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.js @@ -1,5 +1,4 @@ //// [declFileObjectLiteralWithOnlySetter.ts] - function /*1*/makePoint(x: number) { return { b: 10, diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.symbols b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.symbols index f747446614018..8029baed4ad71 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.symbols +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.symbols @@ -1,26 +1,25 @@ === tests/cases/compiler/declFileObjectLiteralWithOnlySetter.ts === - function /*1*/makePoint(x: number) { >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithOnlySetter.ts, 0, 0)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 1, 24)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 0, 24)) return { b: 10, ->b : Symbol(b, Decl(declFileObjectLiteralWithOnlySetter.ts, 2, 12)) +>b : Symbol(b, Decl(declFileObjectLiteralWithOnlySetter.ts, 1, 12)) set x(a: number) { this.b = a; } ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) ->a : Symbol(a, Decl(declFileObjectLiteralWithOnlySetter.ts, 4, 14)) ->a : Symbol(a, Decl(declFileObjectLiteralWithOnlySetter.ts, 4, 14)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 2, 14)) +>a : Symbol(a, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) +>a : Symbol(a, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) }; }; var /*3*/point = makePoint(2); ->point : Symbol(point, Decl(declFileObjectLiteralWithOnlySetter.ts, 7, 3)) +>point : Symbol(point, Decl(declFileObjectLiteralWithOnlySetter.ts, 6, 3)) >makePoint : Symbol(makePoint, Decl(declFileObjectLiteralWithOnlySetter.ts, 0, 0)) point./*2*/x = 30; ->point./*2*/x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) ->point : Symbol(point, Decl(declFileObjectLiteralWithOnlySetter.ts, 7, 3)) ->x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 3, 14)) +>point./*2*/x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 2, 14)) +>point : Symbol(point, Decl(declFileObjectLiteralWithOnlySetter.ts, 6, 3)) +>x : Symbol(x, Decl(declFileObjectLiteralWithOnlySetter.ts, 2, 14)) diff --git a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.types b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.types index 2f15818e0f2e5..67beef0e9107c 100644 --- a/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.types +++ b/tests/baselines/reference/declFileObjectLiteralWithOnlySetter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileObjectLiteralWithOnlySetter.ts === - function /*1*/makePoint(x: number) { >makePoint : (x: number) => { b: number; x: number; } >x : number diff --git a/tests/baselines/reference/declFilePrivateMethodOverloads.js b/tests/baselines/reference/declFilePrivateMethodOverloads.js index 531b60367a241..f2203d8d770f4 100644 --- a/tests/baselines/reference/declFilePrivateMethodOverloads.js +++ b/tests/baselines/reference/declFilePrivateMethodOverloads.js @@ -1,5 +1,4 @@ //// [declFilePrivateMethodOverloads.ts] - interface IContext { someMethod(); } diff --git a/tests/baselines/reference/declFilePrivateMethodOverloads.symbols b/tests/baselines/reference/declFilePrivateMethodOverloads.symbols index 6471ee7f5e7e6..5febff1b31a2a 100644 --- a/tests/baselines/reference/declFilePrivateMethodOverloads.symbols +++ b/tests/baselines/reference/declFilePrivateMethodOverloads.symbols @@ -1,76 +1,75 @@ === tests/cases/compiler/declFilePrivateMethodOverloads.ts === - interface IContext { >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) someMethod(); ->someMethod : Symbol(IContext.someMethod, Decl(declFilePrivateMethodOverloads.ts, 1, 20)) +>someMethod : Symbol(IContext.someMethod, Decl(declFilePrivateMethodOverloads.ts, 0, 20)) } class c1 { ->c1 : Symbol(c1, Decl(declFilePrivateMethodOverloads.ts, 3, 1)) +>c1 : Symbol(c1, Decl(declFilePrivateMethodOverloads.ts, 2, 1)) private _forEachBindingContext(bindingContext: IContext, fn: (bindingContext: IContext) => void); ->_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 10), Decl(declFilePrivateMethodOverloads.ts, 5, 101), Decl(declFilePrivateMethodOverloads.ts, 6, 113)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 5, 35)) +>_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 3, 10), Decl(declFilePrivateMethodOverloads.ts, 4, 101), Decl(declFilePrivateMethodOverloads.ts, 5, 113)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 35)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 5, 60)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 5, 66)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 4, 60)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 66)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) private _forEachBindingContext(bindingContextArray: Array, fn: (bindingContext: IContext) => void); ->_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 10), Decl(declFilePrivateMethodOverloads.ts, 5, 101), Decl(declFilePrivateMethodOverloads.ts, 6, 113)) ->bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 6, 35)) +>_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 3, 10), Decl(declFilePrivateMethodOverloads.ts, 4, 101), Decl(declFilePrivateMethodOverloads.ts, 5, 113)) +>bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 5, 35)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 6, 72)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 6, 78)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 5, 72)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 5, 78)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) private _forEachBindingContext(context, fn: (bindingContext: IContext) => void): void { ->_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 10), Decl(declFilePrivateMethodOverloads.ts, 5, 101), Decl(declFilePrivateMethodOverloads.ts, 6, 113)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 7, 35)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 7, 43)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 7, 49)) +>_forEachBindingContext : Symbol(c1._forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 3, 10), Decl(declFilePrivateMethodOverloads.ts, 4, 101), Decl(declFilePrivateMethodOverloads.ts, 5, 113)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 6, 35)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 6, 43)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 6, 49)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) // Function here } private overloadWithArityDifference(bindingContext: IContext); ->overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 9, 5), Decl(declFilePrivateMethodOverloads.ts, 11, 66), Decl(declFilePrivateMethodOverloads.ts, 12, 118)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 11, 40)) +>overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 8, 5), Decl(declFilePrivateMethodOverloads.ts, 10, 66), Decl(declFilePrivateMethodOverloads.ts, 11, 118)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 10, 40)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) private overloadWithArityDifference(bindingContextArray: Array, fn: (bindingContext: IContext) => void); ->overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 9, 5), Decl(declFilePrivateMethodOverloads.ts, 11, 66), Decl(declFilePrivateMethodOverloads.ts, 12, 118)) ->bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 12, 40)) +>overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 8, 5), Decl(declFilePrivateMethodOverloads.ts, 10, 66), Decl(declFilePrivateMethodOverloads.ts, 11, 118)) +>bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 11, 40)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 12, 77)) ->bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 12, 83)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 11, 77)) +>bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 11, 83)) >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0)) private overloadWithArityDifference(context): void { ->overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 9, 5), Decl(declFilePrivateMethodOverloads.ts, 11, 66), Decl(declFilePrivateMethodOverloads.ts, 12, 118)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 13, 40)) +>overloadWithArityDifference : Symbol(c1.overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 8, 5), Decl(declFilePrivateMethodOverloads.ts, 10, 66), Decl(declFilePrivateMethodOverloads.ts, 11, 118)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 12, 40)) // Function here } } declare class c2 { ->c2 : Symbol(c2, Decl(declFilePrivateMethodOverloads.ts, 16, 1)) +>c2 : Symbol(c2, Decl(declFilePrivateMethodOverloads.ts, 15, 1)) private overload1(context, fn); ->overload1 : Symbol(c2.overload1, Decl(declFilePrivateMethodOverloads.ts, 17, 18)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 18, 22)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 18, 30)) +>overload1 : Symbol(c2.overload1, Decl(declFilePrivateMethodOverloads.ts, 16, 18)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 17, 22)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 17, 30)) private overload2(context); ->overload2 : Symbol(c2.overload2, Decl(declFilePrivateMethodOverloads.ts, 18, 35), Decl(declFilePrivateMethodOverloads.ts, 20, 31)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 20, 22)) +>overload2 : Symbol(c2.overload2, Decl(declFilePrivateMethodOverloads.ts, 17, 35), Decl(declFilePrivateMethodOverloads.ts, 19, 31)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 19, 22)) private overload2(context, fn); ->overload2 : Symbol(c2.overload2, Decl(declFilePrivateMethodOverloads.ts, 18, 35), Decl(declFilePrivateMethodOverloads.ts, 20, 31)) ->context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 21, 22)) ->fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 21, 30)) +>overload2 : Symbol(c2.overload2, Decl(declFilePrivateMethodOverloads.ts, 17, 35), Decl(declFilePrivateMethodOverloads.ts, 19, 31)) +>context : Symbol(context, Decl(declFilePrivateMethodOverloads.ts, 20, 22)) +>fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 20, 30)) } diff --git a/tests/baselines/reference/declFilePrivateMethodOverloads.types b/tests/baselines/reference/declFilePrivateMethodOverloads.types index 9989fea31f090..9fcd174180074 100644 --- a/tests/baselines/reference/declFilePrivateMethodOverloads.types +++ b/tests/baselines/reference/declFilePrivateMethodOverloads.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFilePrivateMethodOverloads.ts === - interface IContext { >IContext : IContext diff --git a/tests/baselines/reference/declFilePrivateStatic.js b/tests/baselines/reference/declFilePrivateStatic.js index fb24bea766088..cb1b47735f31b 100644 --- a/tests/baselines/reference/declFilePrivateStatic.js +++ b/tests/baselines/reference/declFilePrivateStatic.js @@ -1,5 +1,4 @@ //// [declFilePrivateStatic.ts] - class C { private static x = 1; static y = 1; diff --git a/tests/baselines/reference/declFilePrivateStatic.symbols b/tests/baselines/reference/declFilePrivateStatic.symbols index d3d0753123c6d..b8c2318bcdbce 100644 --- a/tests/baselines/reference/declFilePrivateStatic.symbols +++ b/tests/baselines/reference/declFilePrivateStatic.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/declFilePrivateStatic.ts === - class C { >C : Symbol(C, Decl(declFilePrivateStatic.ts, 0, 0)) private static x = 1; ->x : Symbol(C.x, Decl(declFilePrivateStatic.ts, 1, 9)) +>x : Symbol(C.x, Decl(declFilePrivateStatic.ts, 0, 9)) static y = 1; ->y : Symbol(C.y, Decl(declFilePrivateStatic.ts, 2, 25)) +>y : Symbol(C.y, Decl(declFilePrivateStatic.ts, 1, 25)) private static a() { } ->a : Symbol(C.a, Decl(declFilePrivateStatic.ts, 3, 17)) +>a : Symbol(C.a, Decl(declFilePrivateStatic.ts, 2, 17)) static b() { } ->b : Symbol(C.b, Decl(declFilePrivateStatic.ts, 5, 26)) +>b : Symbol(C.b, Decl(declFilePrivateStatic.ts, 4, 26)) private static get c() { return 1; } ->c : Symbol(C.c, Decl(declFilePrivateStatic.ts, 6, 18)) +>c : Symbol(C.c, Decl(declFilePrivateStatic.ts, 5, 18)) static get d() { return 1; } ->d : Symbol(C.d, Decl(declFilePrivateStatic.ts, 8, 40)) +>d : Symbol(C.d, Decl(declFilePrivateStatic.ts, 7, 40)) private static set e(v) { } ->e : Symbol(C.e, Decl(declFilePrivateStatic.ts, 9, 32)) ->v : Symbol(v, Decl(declFilePrivateStatic.ts, 11, 25)) +>e : Symbol(C.e, Decl(declFilePrivateStatic.ts, 8, 32)) +>v : Symbol(v, Decl(declFilePrivateStatic.ts, 10, 25)) static set f(v) { } ->f : Symbol(C.f, Decl(declFilePrivateStatic.ts, 11, 31)) ->v : Symbol(v, Decl(declFilePrivateStatic.ts, 12, 17)) +>f : Symbol(C.f, Decl(declFilePrivateStatic.ts, 10, 31)) +>v : Symbol(v, Decl(declFilePrivateStatic.ts, 11, 17)) } diff --git a/tests/baselines/reference/declFilePrivateStatic.types b/tests/baselines/reference/declFilePrivateStatic.types index 29f8f1a9aab8a..c7d162800a73b 100644 --- a/tests/baselines/reference/declFilePrivateStatic.types +++ b/tests/baselines/reference/declFilePrivateStatic.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFilePrivateStatic.ts === - class C { >C : C diff --git a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.js b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.js index 894f50fc5abf0..fb0d984dbb2ec 100644 --- a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.js +++ b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.js @@ -1,5 +1,4 @@ //// [declFileRestParametersOfFunctionAndFunctionType.ts] - function f1(...args) { } function f2(x: (...args) => void) { } function f3(x: { (...args): void }) { } diff --git a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols index 49758e4ceb1e4..a74786e480226 100644 --- a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols +++ b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/declFileRestParametersOfFunctionAndFunctionType.ts === - function f1(...args) { } >f1 : Symbol(f1, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 0, 0)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 0, 12)) function f2(x: (...args) => void) { } ->f2 : Symbol(f2, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 24)) ->x : Symbol(x, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 12)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 16)) +>f2 : Symbol(f2, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 0, 24)) +>x : Symbol(x, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 16)) function f3(x: { (...args): void }) { } ->f3 : Symbol(f3, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 37)) ->x : Symbol(x, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 12)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 18)) +>f3 : Symbol(f3, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 1, 37)) +>x : Symbol(x, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 18)) function f4 void>() { } ->f4 : Symbol(f4, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 39)) ->T : Symbol(T, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 12)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 23)) +>f4 : Symbol(f4, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 2, 39)) +>T : Symbol(T, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 23)) function f5() { } ->f5 : Symbol(f5, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 46)) ->T : Symbol(T, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 5, 12)) ->args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 5, 25)) +>f5 : Symbol(f5, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 3, 46)) +>T : Symbol(T, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 12)) +>args : Symbol(args, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 4, 25)) var f6 = () => { return [10]; } ->f6 : Symbol(f6, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 6, 3)) +>f6 : Symbol(f6, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 5, 3)) diff --git a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.types b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.types index 8e0cdd8d40966..d94f1bfc42174 100644 --- a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.types +++ b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileRestParametersOfFunctionAndFunctionType.ts === - function f1(...args) { } >f1 : (...args: any[]) => void >args : any[] diff --git a/tests/baselines/reference/declFileTypeAnnotationArrayType.js b/tests/baselines/reference/declFileTypeAnnotationArrayType.js index 54dd7bbbc23ae..53a5ac59a4787 100644 --- a/tests/baselines/reference/declFileTypeAnnotationArrayType.js +++ b/tests/baselines/reference/declFileTypeAnnotationArrayType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationArrayType.ts] - class c { } module m { diff --git a/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols b/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols index 9092189c3c734..537319fe4393b 100644 --- a/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/declFileTypeAnnotationArrayType.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationArrayType.ts, 6, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationArrayType.ts, 5, 19)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 8, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationArrayType.ts, 9, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 7, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationArrayType.ts, 8, 8)) } // Just the name function foo(): c[] { ->foo : Symbol(foo, Decl(declFileTypeAnnotationArrayType.ts, 10, 1)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationArrayType.ts, 9, 1)) >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) return [new c()]; >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) } function foo2() { ->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationArrayType.ts, 15, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationArrayType.ts, 14, 1)) return [new c()]; >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) @@ -36,69 +35,69 @@ function foo2() { // Qualified name function foo3(): m.c[] { ->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationArrayType.ts, 18, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) +>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationArrayType.ts, 17, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) return [new m.c()]; ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) } function foo4() { ->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationArrayType.ts, 23, 1)) +>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationArrayType.ts, 22, 1)) return m.c; ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationArrayType.ts, 2, 10)) } // Just the name with type arguments function foo5(): g[] { ->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationArrayType.ts, 26, 1)) ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 8, 1)) +>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationArrayType.ts, 25, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 7, 1)) return [new g()]; ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 7, 1)) } function foo6() { ->foo6 : Symbol(foo6, Decl(declFileTypeAnnotationArrayType.ts, 31, 1)) +>foo6 : Symbol(foo6, Decl(declFileTypeAnnotationArrayType.ts, 30, 1)) return [new g()]; ->g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationArrayType.ts, 7, 1)) } // Qualified name with type arguments function foo7(): m.g[] { ->foo7 : Symbol(foo7, Decl(declFileTypeAnnotationArrayType.ts, 34, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) +>foo7 : Symbol(foo7, Decl(declFileTypeAnnotationArrayType.ts, 33, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) return [new m.g()]; ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) } function foo8() { ->foo8 : Symbol(foo8, Decl(declFileTypeAnnotationArrayType.ts, 39, 1)) +>foo8 : Symbol(foo8, Decl(declFileTypeAnnotationArrayType.ts, 38, 1)) return [new m.g()]; ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationArrayType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationArrayType.ts, 4, 5)) } // Array of function types function foo9(): (()=>c)[] { ->foo9 : Symbol(foo9, Decl(declFileTypeAnnotationArrayType.ts, 42, 1)) +>foo9 : Symbol(foo9, Decl(declFileTypeAnnotationArrayType.ts, 41, 1)) >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) return [() => new c()]; >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) } function foo10() { ->foo10 : Symbol(foo10, Decl(declFileTypeAnnotationArrayType.ts, 47, 1)) +>foo10 : Symbol(foo10, Decl(declFileTypeAnnotationArrayType.ts, 46, 1)) return [() => new c()]; >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileTypeAnnotationArrayType.types b/tests/baselines/reference/declFileTypeAnnotationArrayType.types index 7a9d65b8a1f2d..6e79822782660 100644 --- a/tests/baselines/reference/declFileTypeAnnotationArrayType.types +++ b/tests/baselines/reference/declFileTypeAnnotationArrayType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationArrayType.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.js b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.js index fc877ab4b326e..10d6539be942f 100644 --- a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.js +++ b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationBuiltInType.ts] - // string function foo(): string { return ""; diff --git a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.symbols b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.symbols index 62de15530b77b..91b022e141825 100644 --- a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationBuiltInType.ts === - // string function foo(): string { >foo : Symbol(foo, Decl(declFileTypeAnnotationBuiltInType.ts, 0, 0)) @@ -7,56 +6,56 @@ function foo(): string { return ""; } function foo2() { ->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationBuiltInType.ts, 4, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationBuiltInType.ts, 3, 1)) return ""; } // number function foo3(): number { ->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationBuiltInType.ts, 7, 1)) +>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationBuiltInType.ts, 6, 1)) return 10; } function foo4() { ->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationBuiltInType.ts, 12, 1)) +>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationBuiltInType.ts, 11, 1)) return 10; } // boolean function foo5(): boolean { ->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationBuiltInType.ts, 15, 1)) +>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationBuiltInType.ts, 14, 1)) return true; } function foo6() { ->foo6 : Symbol(foo6, Decl(declFileTypeAnnotationBuiltInType.ts, 20, 1)) +>foo6 : Symbol(foo6, Decl(declFileTypeAnnotationBuiltInType.ts, 19, 1)) return false; } // void function foo7(): void { ->foo7 : Symbol(foo7, Decl(declFileTypeAnnotationBuiltInType.ts, 23, 1)) +>foo7 : Symbol(foo7, Decl(declFileTypeAnnotationBuiltInType.ts, 22, 1)) return; } function foo8() { ->foo8 : Symbol(foo8, Decl(declFileTypeAnnotationBuiltInType.ts, 28, 1)) +>foo8 : Symbol(foo8, Decl(declFileTypeAnnotationBuiltInType.ts, 27, 1)) return; } // any function foo9(): any { ->foo9 : Symbol(foo9, Decl(declFileTypeAnnotationBuiltInType.ts, 31, 1)) +>foo9 : Symbol(foo9, Decl(declFileTypeAnnotationBuiltInType.ts, 30, 1)) return undefined; >undefined : Symbol(undefined) } function foo10() { ->foo10 : Symbol(foo10, Decl(declFileTypeAnnotationBuiltInType.ts, 36, 1)) +>foo10 : Symbol(foo10, Decl(declFileTypeAnnotationBuiltInType.ts, 35, 1)) return undefined; >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types index 87776b3b41793..c30b5b95b81a9 100644 --- a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types +++ b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationBuiltInType.ts === - // string function foo(): string { >foo : () => string diff --git a/tests/baselines/reference/declFileTypeAnnotationParenType.js b/tests/baselines/reference/declFileTypeAnnotationParenType.js index 4707007cd1b3f..e867f2069c4e4 100644 --- a/tests/baselines/reference/declFileTypeAnnotationParenType.js +++ b/tests/baselines/reference/declFileTypeAnnotationParenType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationParenType.ts] - class c { private p: string; } diff --git a/tests/baselines/reference/declFileTypeAnnotationParenType.symbols b/tests/baselines/reference/declFileTypeAnnotationParenType.symbols index 7186da48fd737..fbe94d26da43f 100644 --- a/tests/baselines/reference/declFileTypeAnnotationParenType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationParenType.symbols @@ -1,27 +1,26 @@ === tests/cases/compiler/declFileTypeAnnotationParenType.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) private p: string; ->p : Symbol(c.p, Decl(declFileTypeAnnotationParenType.ts, 1, 9)) +>p : Symbol(c.p, Decl(declFileTypeAnnotationParenType.ts, 0, 9)) } var x: (() => c)[] = [() => new c()]; ->x : Symbol(x, Decl(declFileTypeAnnotationParenType.ts, 5, 3)) +>x : Symbol(x, Decl(declFileTypeAnnotationParenType.ts, 4, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) var y = [() => new c()]; ->y : Symbol(y, Decl(declFileTypeAnnotationParenType.ts, 6, 3)) +>y : Symbol(y, Decl(declFileTypeAnnotationParenType.ts, 5, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) var k: (() => c) | string = (() => new c()) || ""; ->k : Symbol(k, Decl(declFileTypeAnnotationParenType.ts, 8, 3)) +>k : Symbol(k, Decl(declFileTypeAnnotationParenType.ts, 7, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) var l = (() => new c()) || ""; ->l : Symbol(l, Decl(declFileTypeAnnotationParenType.ts, 9, 3)) +>l : Symbol(l, Decl(declFileTypeAnnotationParenType.ts, 8, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileTypeAnnotationParenType.types b/tests/baselines/reference/declFileTypeAnnotationParenType.types index 1fd0b6ee5d958..a73c9bba0a95a 100644 --- a/tests/baselines/reference/declFileTypeAnnotationParenType.types +++ b/tests/baselines/reference/declFileTypeAnnotationParenType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationParenType.ts === - class c { >c : c diff --git a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.js b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.js index faa76cc869c9a..9332c175fd0ec 100644 --- a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.js +++ b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationStringLiteral.ts] - function foo(a: "hello"): number; function foo(a: "name"): string; function foo(a: string): string | number; diff --git a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols index f48ced073d57c..d2e6afe63e8e1 100644 --- a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/declFileTypeAnnotationStringLiteral.ts === - function foo(a: "hello"): number; ->foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 3, 41)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 1, 13)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 0, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 41)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 13)) function foo(a: "name"): string; ->foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 3, 41)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 2, 13)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 0, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 41)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 1, 13)) function foo(a: string): string | number; ->foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 3, 41)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 0, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 41)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 2, 13)) function foo(a: string): string | number { ->foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 3, 41)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationStringLiteral.ts, 0, 0), Decl(declFileTypeAnnotationStringLiteral.ts, 0, 33), Decl(declFileTypeAnnotationStringLiteral.ts, 1, 32), Decl(declFileTypeAnnotationStringLiteral.ts, 2, 41)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) if (a === "hello") { ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) return a.length; >a.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } return a; ->a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) +>a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 3, 13)) } diff --git a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.types b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.types index b1a85f3fc3038..04bd4e53e8e29 100644 --- a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.types +++ b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationStringLiteral.ts === - function foo(a: "hello"): number; >foo : { (a: "hello"): number; (a: "name"): string; (a: string): string | number; } >a : "hello" diff --git a/tests/baselines/reference/declFileTypeAnnotationTupleType.js b/tests/baselines/reference/declFileTypeAnnotationTupleType.js index 323fdce03f9ee..f4f1a32c8c095 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTupleType.js +++ b/tests/baselines/reference/declFileTypeAnnotationTupleType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTupleType.ts] - class c { } module m { diff --git a/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols b/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols index 9eea6dfd9f953..6f2314d22b531 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/declFileTypeAnnotationTupleType.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 3, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 2, 10)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationTupleType.ts, 6, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 4, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationTupleType.ts, 5, 19)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 8, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationTupleType.ts, 9, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 7, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationTupleType.ts, 8, 8)) } // Just the name var k: [c, m.c] = [new c(), new m.c()]; ->k : Symbol(k, Decl(declFileTypeAnnotationTupleType.ts, 13, 3)) +>k : Symbol(k, Decl(declFileTypeAnnotationTupleType.ts, 12, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 3, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 2, 10)) >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTupleType.ts, 2, 10)) var l = k; ->l : Symbol(l, Decl(declFileTypeAnnotationTupleType.ts, 14, 3)) ->k : Symbol(k, Decl(declFileTypeAnnotationTupleType.ts, 13, 3)) +>l : Symbol(l, Decl(declFileTypeAnnotationTupleType.ts, 13, 3)) +>k : Symbol(k, Decl(declFileTypeAnnotationTupleType.ts, 12, 3)) var x: [g, m.g, () => c] = [new g(), new m.g(), () => new c()]; ->x : Symbol(x, Decl(declFileTypeAnnotationTupleType.ts, 16, 3)) ->g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 8, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5)) +>x : Symbol(x, Decl(declFileTypeAnnotationTupleType.ts, 15, 3)) +>g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 7, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 4, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) ->g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 8, 1)) ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5)) +>g : Symbol(g, Decl(declFileTypeAnnotationTupleType.ts, 7, 1)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 4, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0)) var y = x; ->y : Symbol(y, Decl(declFileTypeAnnotationTupleType.ts, 17, 3)) ->x : Symbol(x, Decl(declFileTypeAnnotationTupleType.ts, 16, 3)) +>y : Symbol(y, Decl(declFileTypeAnnotationTupleType.ts, 16, 3)) +>x : Symbol(x, Decl(declFileTypeAnnotationTupleType.ts, 15, 3)) diff --git a/tests/baselines/reference/declFileTypeAnnotationTupleType.types b/tests/baselines/reference/declFileTypeAnnotationTupleType.types index aad0760fade3d..03de87243de67 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTupleType.types +++ b/tests/baselines/reference/declFileTypeAnnotationTupleType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTupleType.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.js b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.js index 171625efe1a46..1ca73a7889117 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.js +++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTypeAlias.ts] - module M { export type Value = string | number | boolean; export var x: Value; diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols index d12902b6f1992..168971f364f51 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols @@ -1,63 +1,62 @@ === tests/cases/compiler/declFileTypeAnnotationTypeAlias.ts === - module M { ->M : Symbol(M, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 0), Decl(declFileTypeAnnotationTypeAlias.ts, 22, 1)) +>M : Symbol(M, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 0), Decl(declFileTypeAnnotationTypeAlias.ts, 21, 1)) export type Value = string | number | boolean; ->Value : Symbol(Value, Decl(declFileTypeAnnotationTypeAlias.ts, 1, 10)) +>Value : Symbol(Value, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 10)) export var x: Value; ->x : Symbol(x, Decl(declFileTypeAnnotationTypeAlias.ts, 3, 14)) ->Value : Symbol(Value, Decl(declFileTypeAnnotationTypeAlias.ts, 1, 10)) +>x : Symbol(x, Decl(declFileTypeAnnotationTypeAlias.ts, 2, 14)) +>Value : Symbol(Value, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 10)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 3, 24)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 2, 24)) } export type C = c; ->C : Symbol(C, Decl(declFileTypeAnnotationTypeAlias.ts, 6, 5)) ->c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 3, 24)) +>C : Symbol(C, Decl(declFileTypeAnnotationTypeAlias.ts, 5, 5)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 2, 24)) export module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTypeAlias.ts, 8, 22)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeAlias.ts, 7, 22)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 10, 21)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 9, 21)) } } export type MC = m.c; ->MC : Symbol(MC, Decl(declFileTypeAnnotationTypeAlias.ts, 13, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeAlias.ts, 8, 22)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeAlias.ts, 10, 21)) +>MC : Symbol(MC, Decl(declFileTypeAnnotationTypeAlias.ts, 12, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeAlias.ts, 7, 22)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeAlias.ts, 9, 21)) export type fc = () => c; ->fc : Symbol(fc, Decl(declFileTypeAnnotationTypeAlias.ts, 15, 25)) ->c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 3, 24)) +>fc : Symbol(fc, Decl(declFileTypeAnnotationTypeAlias.ts, 14, 25)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeAlias.ts, 2, 24)) } interface Window { ->Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 18, 1)) +>Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 17, 1)) someMethod(); ->someMethod : Symbol(Window.someMethod, Decl(declFileTypeAnnotationTypeAlias.ts, 20, 18)) +>someMethod : Symbol(Window.someMethod, Decl(declFileTypeAnnotationTypeAlias.ts, 19, 18)) } module M { ->M : Symbol(M, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 0), Decl(declFileTypeAnnotationTypeAlias.ts, 22, 1)) +>M : Symbol(M, Decl(declFileTypeAnnotationTypeAlias.ts, 0, 0), Decl(declFileTypeAnnotationTypeAlias.ts, 21, 1)) export type W = Window | string; ->W : Symbol(W, Decl(declFileTypeAnnotationTypeAlias.ts, 24, 10)) ->Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 18, 1)) +>W : Symbol(W, Decl(declFileTypeAnnotationTypeAlias.ts, 23, 10)) +>Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 17, 1)) export module N { ->N : Symbol(N, Decl(declFileTypeAnnotationTypeAlias.ts, 25, 36)) +>N : Symbol(N, Decl(declFileTypeAnnotationTypeAlias.ts, 24, 36)) export class Window { } ->Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 26, 21)) +>Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 25, 21)) export var p: W; ->p : Symbol(p, Decl(declFileTypeAnnotationTypeAlias.ts, 28, 18)) ->W : Symbol(W, Decl(declFileTypeAnnotationTypeAlias.ts, 24, 10)) +>p : Symbol(p, Decl(declFileTypeAnnotationTypeAlias.ts, 27, 18)) +>W : Symbol(W, Decl(declFileTypeAnnotationTypeAlias.ts, 23, 10)) } } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types index 53db7a54d0d46..37955f25a6dc2 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types +++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTypeAlias.ts === - module M { >M : typeof M diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.js b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.js index befd96a9fa741..f2247e8daa982 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.js +++ b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTypeLiteral.ts] - class c { } class g { diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.symbols index 6a3f2100fab3f..cea4cd09db3ad 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.symbols @@ -1,71 +1,70 @@ === tests/cases/compiler/declFileTypeAnnotationTypeLiteral.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeLiteral.ts, 3, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 1, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 8)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 3, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 5, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 10)) } } // Object literal with everything var x: { ->x : Symbol(x, Decl(declFileTypeAnnotationTypeLiteral.ts, 11, 3)) +>x : Symbol(x, Decl(declFileTypeAnnotationTypeLiteral.ts, 10, 3)) // Call signatures (a: number): c; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 13, 5)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 12, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) (a: string): g; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 14, 5)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 1)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 13, 5)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 1, 1)) // Construct signatures new (a: number): c; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 17, 9)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 16, 9)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) new (a: string): m.c; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 18, 9)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeLiteral.ts, 5, 10)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 17, 9)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 3, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 10)) // Indexers [n: number]: c; ->n : Symbol(n, Decl(declFileTypeAnnotationTypeLiteral.ts, 21, 5)) +>n : Symbol(n, Decl(declFileTypeAnnotationTypeLiteral.ts, 20, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) [n: string]: c; ->n : Symbol(n, Decl(declFileTypeAnnotationTypeLiteral.ts, 22, 5)) +>n : Symbol(n, Decl(declFileTypeAnnotationTypeLiteral.ts, 21, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) // Properties a: c; ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 22, 19)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 21, 19)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) b: g; ->b : Symbol(b, Decl(declFileTypeAnnotationTypeLiteral.ts, 25, 9)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 1)) +>b : Symbol(b, Decl(declFileTypeAnnotationTypeLiteral.ts, 24, 9)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 1, 1)) // methods m1(): g; ->m1 : Symbol(m1, Decl(declFileTypeAnnotationTypeLiteral.ts, 26, 17)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 2, 1)) +>m1 : Symbol(m1, Decl(declFileTypeAnnotationTypeLiteral.ts, 25, 17)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeLiteral.ts, 1, 1)) m2(a: string, b?: number, ...c: c[]): string; ->m2 : Symbol(m2, Decl(declFileTypeAnnotationTypeLiteral.ts, 29, 20)) ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 30, 7)) ->b : Symbol(b, Decl(declFileTypeAnnotationTypeLiteral.ts, 30, 17)) ->c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 30, 29)) +>m2 : Symbol(m2, Decl(declFileTypeAnnotationTypeLiteral.ts, 28, 20)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 29, 7)) +>b : Symbol(b, Decl(declFileTypeAnnotationTypeLiteral.ts, 29, 17)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 29, 29)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeLiteral.ts, 0, 0)) }; @@ -73,13 +72,13 @@ var x: { // Function type var y: (a: string) => string; ->y : Symbol(y, Decl(declFileTypeAnnotationTypeLiteral.ts, 35, 3)) ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 35, 8)) +>y : Symbol(y, Decl(declFileTypeAnnotationTypeLiteral.ts, 34, 3)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 34, 8)) // constructor type var z: new (a: string) => m.c; ->z : Symbol(z, Decl(declFileTypeAnnotationTypeLiteral.ts, 38, 3)) ->a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 38, 12)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeLiteral.ts, 5, 10)) +>z : Symbol(z, Decl(declFileTypeAnnotationTypeLiteral.ts, 37, 3)) +>a : Symbol(a, Decl(declFileTypeAnnotationTypeLiteral.ts, 37, 12)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeLiteral.ts, 3, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeLiteral.ts, 4, 10)) diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.types b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.types index e20920083588e..e1aa1a26611cf 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.types +++ b/tests/baselines/reference/declFileTypeAnnotationTypeLiteral.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTypeLiteral.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.js b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.js index e64e81e4939e2..e2d6fee1f4ff9 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.js +++ b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTypeQuery.ts] - class c { } module m { diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.symbols index f5970ce15f51e..874a0546dbdd2 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/declFileTypeAnnotationTypeQuery.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 0, 0)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeQuery.ts, 6, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 19)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeQuery.ts, 9, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 7, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 8)) } // Just the name function foo(): typeof c { ->foo : Symbol(foo, Decl(declFileTypeAnnotationTypeQuery.ts, 10, 1)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationTypeQuery.ts, 9, 1)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 0, 0)) return c; >c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 0, 0)) } function foo2() { ->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationTypeQuery.ts, 15, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationTypeQuery.ts, 14, 1)) return c; >c : Symbol(c, Decl(declFileTypeAnnotationTypeQuery.ts, 0, 0)) @@ -36,57 +35,57 @@ function foo2() { // Qualified name function foo3(): typeof m.c { ->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationTypeQuery.ts, 18, 1)) ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) +>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationTypeQuery.ts, 17, 1)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) return m.c; ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) } function foo4() { ->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationTypeQuery.ts, 23, 1)) +>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationTypeQuery.ts, 22, 1)) return m.c; ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 10)) } // Just the name with type arguments function foo5(): typeof g { ->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationTypeQuery.ts, 26, 1)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 1)) +>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationTypeQuery.ts, 25, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 7, 1)) return g; ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 7, 1)) } function foo6() { ->foo6 : Symbol(foo6, Decl(declFileTypeAnnotationTypeQuery.ts, 31, 1)) +>foo6 : Symbol(foo6, Decl(declFileTypeAnnotationTypeQuery.ts, 30, 1)) return g; ->g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeQuery.ts, 7, 1)) } // Qualified name with type arguments function foo7(): typeof m.g { ->foo7 : Symbol(foo7, Decl(declFileTypeAnnotationTypeQuery.ts, 34, 1)) ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) +>foo7 : Symbol(foo7, Decl(declFileTypeAnnotationTypeQuery.ts, 33, 1)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) return m.g ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) } function foo8() { ->foo8 : Symbol(foo8, Decl(declFileTypeAnnotationTypeQuery.ts, 39, 1)) +>foo8 : Symbol(foo8, Decl(declFileTypeAnnotationTypeQuery.ts, 38, 1)) return m.g ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeQuery.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeQuery.ts, 4, 5)) } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.types b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.types index 01fce150ab896..cdf9ab3793695 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeQuery.types +++ b/tests/baselines/reference/declFileTypeAnnotationTypeQuery.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTypeQuery.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeReference.js b/tests/baselines/reference/declFileTypeAnnotationTypeReference.js index 7d2e7102fb652..7eebd30e54bf7 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeReference.js +++ b/tests/baselines/reference/declFileTypeAnnotationTypeReference.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationTypeReference.ts] - class c { } module m { diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeReference.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeReference.symbols index c6e27ecdcebce..ab8ab66b004e3 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeReference.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationTypeReference.symbols @@ -1,34 +1,33 @@ === tests/cases/compiler/declFileTypeAnnotationTypeReference.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 0, 0)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeReference.ts, 6, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeReference.ts, 5, 19)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 8, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationTypeReference.ts, 9, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 7, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationTypeReference.ts, 8, 8)) } // Just the name function foo(): c { ->foo : Symbol(foo, Decl(declFileTypeAnnotationTypeReference.ts, 10, 1)) +>foo : Symbol(foo, Decl(declFileTypeAnnotationTypeReference.ts, 9, 1)) >c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 0, 0)) return new c(); >c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 0, 0)) } function foo2() { ->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationTypeReference.ts, 15, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationTypeReference.ts, 14, 1)) return new c(); >c : Symbol(c, Decl(declFileTypeAnnotationTypeReference.ts, 0, 0)) @@ -36,55 +35,55 @@ function foo2() { // Qualified name function foo3(): m.c { ->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationTypeReference.ts, 18, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) +>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationTypeReference.ts, 17, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) return new m.c(); ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) } function foo4() { ->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationTypeReference.ts, 23, 1)) +>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationTypeReference.ts, 22, 1)) return new m.c(); ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 3, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationTypeReference.ts, 2, 10)) } // Just the name with type arguments function foo5(): g { ->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationTypeReference.ts, 26, 1)) ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 8, 1)) +>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationTypeReference.ts, 25, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 7, 1)) return new g(); ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 7, 1)) } function foo6() { ->foo6 : Symbol(foo6, Decl(declFileTypeAnnotationTypeReference.ts, 31, 1)) +>foo6 : Symbol(foo6, Decl(declFileTypeAnnotationTypeReference.ts, 30, 1)) return new g(); ->g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 8, 1)) +>g : Symbol(g, Decl(declFileTypeAnnotationTypeReference.ts, 7, 1)) } // Qualified name with type arguments function foo7(): m.g { ->foo7 : Symbol(foo7, Decl(declFileTypeAnnotationTypeReference.ts, 34, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) +>foo7 : Symbol(foo7, Decl(declFileTypeAnnotationTypeReference.ts, 33, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) return new m.g(); ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) } function foo8() { ->foo8 : Symbol(foo8, Decl(declFileTypeAnnotationTypeReference.ts, 39, 1)) +>foo8 : Symbol(foo8, Decl(declFileTypeAnnotationTypeReference.ts, 38, 1)) return new m.g(); ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 2, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 5, 5)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationTypeReference.ts, 1, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationTypeReference.ts, 4, 5)) } diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeReference.types b/tests/baselines/reference/declFileTypeAnnotationTypeReference.types index 1d85ad1929351..1320354a3a7f7 100644 --- a/tests/baselines/reference/declFileTypeAnnotationTypeReference.types +++ b/tests/baselines/reference/declFileTypeAnnotationTypeReference.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationTypeReference.ts === - class c { >c : c } diff --git a/tests/baselines/reference/declFileTypeAnnotationUnionType.js b/tests/baselines/reference/declFileTypeAnnotationUnionType.js index c90501bab5cdc..b821d15269cc6 100644 --- a/tests/baselines/reference/declFileTypeAnnotationUnionType.js +++ b/tests/baselines/reference/declFileTypeAnnotationUnionType.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationUnionType.ts] - class c { private p: string; } diff --git a/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols b/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols index ac4884326ebbb..4424ae7762d33 100644 --- a/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols @@ -1,71 +1,70 @@ === tests/cases/compiler/declFileTypeAnnotationUnionType.ts === - class c { >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) private p: string; ->p : Symbol(c.p, Decl(declFileTypeAnnotationUnionType.ts, 1, 9)) +>p : Symbol(c.p, Decl(declFileTypeAnnotationUnionType.ts, 0, 9)) } module m { ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) export class c { ->c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) +>c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) private q: string; ->q : Symbol(c.q, Decl(declFileTypeAnnotationUnionType.ts, 5, 20)) +>q : Symbol(c.q, Decl(declFileTypeAnnotationUnionType.ts, 4, 20)) } export class g { ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) ->T : Symbol(T, Decl(declFileTypeAnnotationUnionType.ts, 8, 19)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) +>T : Symbol(T, Decl(declFileTypeAnnotationUnionType.ts, 7, 19)) private r: string; ->r : Symbol(g.r, Decl(declFileTypeAnnotationUnionType.ts, 8, 23)) +>r : Symbol(g.r, Decl(declFileTypeAnnotationUnionType.ts, 7, 23)) } } class g { ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 11, 1)) ->T : Symbol(T, Decl(declFileTypeAnnotationUnionType.ts, 12, 8)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 10, 1)) +>T : Symbol(T, Decl(declFileTypeAnnotationUnionType.ts, 11, 8)) private s: string; ->s : Symbol(g.s, Decl(declFileTypeAnnotationUnionType.ts, 12, 12)) +>s : Symbol(g.s, Decl(declFileTypeAnnotationUnionType.ts, 11, 12)) } // Just the name var k: c | m.c = new c() || new m.c(); ->k : Symbol(k, Decl(declFileTypeAnnotationUnionType.ts, 17, 3)) +>k : Symbol(k, Decl(declFileTypeAnnotationUnionType.ts, 16, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) var l = new c() || new m.c(); ->l : Symbol(l, Decl(declFileTypeAnnotationUnionType.ts, 18, 3)) +>l : Symbol(l, Decl(declFileTypeAnnotationUnionType.ts, 17, 3)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) ->m.c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 4, 10)) +>m.c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>c : Symbol(m.c, Decl(declFileTypeAnnotationUnionType.ts, 3, 10)) var x: g | m.g | (() => c) = new g() || new m.g() || (() => new c()); ->x : Symbol(x, Decl(declFileTypeAnnotationUnionType.ts, 20, 3)) ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 11, 1)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) +>x : Symbol(x, Decl(declFileTypeAnnotationUnionType.ts, 19, 3)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 10, 1)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 11, 1)) ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 10, 1)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) var y = new g() || new m.g() || (() => new c()); ->y : Symbol(y, Decl(declFileTypeAnnotationUnionType.ts, 21, 3)) ->g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 11, 1)) ->m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) ->m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1)) ->g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5)) +>y : Symbol(y, Decl(declFileTypeAnnotationUnionType.ts, 20, 3)) +>g : Symbol(g, Decl(declFileTypeAnnotationUnionType.ts, 10, 1)) +>m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) +>m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 2, 1)) +>g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 6, 5)) >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileTypeAnnotationUnionType.types b/tests/baselines/reference/declFileTypeAnnotationUnionType.types index a412f60b36ed3..115aa7339ca23 100644 --- a/tests/baselines/reference/declFileTypeAnnotationUnionType.types +++ b/tests/baselines/reference/declFileTypeAnnotationUnionType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeAnnotationUnionType.ts === - class c { >c : c diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt index b6130864d8b6c..771960ba788ef 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt @@ -1,17 +1,16 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(16,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(21,13): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(26,25): error TS4037: Parameter 'foo3' of public property setter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(33,25): error TS4037: Parameter 'foo4' of public property setter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(37,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(72,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(77,13): error TS4042: Return type of public property getter from exported class has or is using name 'm2.public2' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(82,27): error TS4037: Parameter 'foo113' of public property setter from exported class has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(89,27): error TS4037: Parameter 'foo114' of public property setter from exported class has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(15,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(20,13): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(25,25): error TS4037: Parameter 'foo3' of public property setter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(32,25): error TS4037: Parameter 'foo4' of public property setter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(36,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(71,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(76,13): error TS4042: Return type of public property getter from exported class has or is using name 'm2.public2' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(81,27): error TS4037: Parameter 'foo113' of public property setter from exported class has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(88,27): error TS4037: Parameter 'foo114' of public property setter from exported class has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(92,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts (10 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.js index 957dbb9826356..be777c3e8ba1e 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorAccessors.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt index 7dbe3617de939..339ae67eea4c1 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(15,34): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(17,26): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(40,35): error TS4078: Parameter 'param' of exported function has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(42,28): error TS4077: Parameter 'param' of exported function has or is using name 'm2.public2' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(14,34): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(16,26): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(39,35): error TS4078: Parameter 'param' of exported function has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(41,28): error TS4077: Parameter 'param' of exported function has or is using name 'm2.public2' from private module 'm2'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts (4 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.js index 7774ee2720603..25b59845c14d6 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt index 449af75bf6153..492e6615efa15 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(17,29): error TS4060: Return type of exported function has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(20,21): error TS4060: Return type of exported function has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(50,31): error TS4060: Return type of exported function has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(53,21): error TS4059: Return type of exported function has or is using name 'm2.public2' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(16,29): error TS4060: Return type of exported function has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(19,21): error TS4060: Return type of exported function has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(49,31): error TS4060: Return type of exported function has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(52,21): error TS4059: Return type of exported function has or is using name 'm2.public2' from private module 'm2'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts (4 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.js index 7e26816beb81a..6cc74c0188ad3 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt index a9fd72ae569d6..919fd5cd6571d 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(10,23): error TS4025: Exported variable 'p' has or is using private name 'W'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(33,22): error TS4081: Exported type alias 't2' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(36,23): error TS4081: Exported type alias 't12' has or is using private name 'public1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(39,24): error TS4081: Exported type alias 't112' has or is using private name 'm3'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(9,23): error TS4025: Exported variable 'p' has or is using private name 'W'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(32,22): error TS4081: Exported type alias 't2' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(35,23): error TS4081: Exported type alias 't12' has or is using private name 'public1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(38,24): error TS4081: Exported type alias 't112' has or is using private name 'm3'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts (4 errors) ==== - interface Window { someMethod(); } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.js index 2b7052903fb09..811ee0575fe0f 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorTypeAlias.ts] - interface Window { someMethod(); } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt index 8cba0d12464d2..a8d8023e8304b 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt @@ -1,25 +1,24 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(11,12): error TS4025: Exported variable 'x' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(12,12): error TS4025: Exported variable 'x' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(13,13): error TS4025: Exported variable 'x' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(14,19): error TS4025: Exported variable 'x' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(15,22): error TS4025: Exported variable 'x' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(16,22): error TS4025: Exported variable 'x' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4024: Exported variable 'x2' has or is using name 'm2.public1' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4025: Exported variable 'x2' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4024: Exported variable 'x3' has or is using name 'm2.public1' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4025: Exported variable 'x3' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,23): error TS4025: Exported variable 'y' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,36): error TS4025: Exported variable 'y' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4024: Exported variable 'y2' has or is using name 'm2.public1' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4025: Exported variable 'y2' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,27): error TS4025: Exported variable 'z' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,40): error TS4025: Exported variable 'z' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4024: Exported variable 'z2' has or is using name 'm2.public1' from private module 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4025: Exported variable 'z2' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(10,12): error TS4025: Exported variable 'x' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(11,12): error TS4025: Exported variable 'x' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(12,13): error TS4025: Exported variable 'x' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(13,19): error TS4025: Exported variable 'x' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(14,22): error TS4025: Exported variable 'x' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(15,22): error TS4025: Exported variable 'x' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(17,16): error TS4024: Exported variable 'x2' has or is using name 'm2.public1' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(17,16): error TS4025: Exported variable 'x2' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(24,16): error TS4024: Exported variable 'x3' has or is using name 'm2.public1' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(24,16): error TS4025: Exported variable 'x3' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(27,23): error TS4025: Exported variable 'y' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(27,36): error TS4025: Exported variable 'y' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,16): error TS4024: Exported variable 'y2' has or is using name 'm2.public1' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,16): error TS4025: Exported variable 'y2' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(31,27): error TS4025: Exported variable 'z' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(31,40): error TS4025: Exported variable 'z' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,16): error TS4024: Exported variable 'z2' has or is using name 'm2.public1' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,16): error TS4025: Exported variable 'z2' has or is using private name 'private1'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts (18 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.js index 46dfaf3c77e80..41f1a094eae10 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorTypeLiteral.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt index 33771b85dd424..6a9e596183133 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(13,19): error TS4025: Exported variable 'k' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(14,16): error TS4025: Exported variable 'l' has or is using private name 'private1'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(30,20): error TS4025: Exported variable 'k3' has or is using private name 'm2'. -tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(31,16): error TS4024: Exported variable 'l3' has or is using name 'm2.public2' from private module 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(12,19): error TS4025: Exported variable 'k' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(13,16): error TS4025: Exported variable 'l' has or is using private name 'private1'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(29,20): error TS4025: Exported variable 'k3' has or is using private name 'm2'. +tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(30,16): error TS4024: Exported variable 'l3' has or is using name 'm2.public2' from private module 'm2'. ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts (4 errors) ==== - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.js b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.js index a75903c7369f8..414a949ce9359 100644 --- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.js +++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.js @@ -1,5 +1,4 @@ //// [declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts] - module m { class private1 { } diff --git a/tests/baselines/reference/declFileTypeofClass.js b/tests/baselines/reference/declFileTypeofClass.js index 7058ace0c9475..03ed0febe733b 100644 --- a/tests/baselines/reference/declFileTypeofClass.js +++ b/tests/baselines/reference/declFileTypeofClass.js @@ -1,5 +1,4 @@ //// [declFileTypeofClass.ts] - class c { static x : string; private static y: number; diff --git a/tests/baselines/reference/declFileTypeofClass.symbols b/tests/baselines/reference/declFileTypeofClass.symbols index 0594edeef7783..443b07f1081ea 100644 --- a/tests/baselines/reference/declFileTypeofClass.symbols +++ b/tests/baselines/reference/declFileTypeofClass.symbols @@ -1,39 +1,38 @@ === tests/cases/compiler/declFileTypeofClass.ts === - class c { >c : Symbol(c, Decl(declFileTypeofClass.ts, 0, 0)) static x : string; ->x : Symbol(c.x, Decl(declFileTypeofClass.ts, 1, 9)) +>x : Symbol(c.x, Decl(declFileTypeofClass.ts, 0, 9)) private static y: number; ->y : Symbol(c.y, Decl(declFileTypeofClass.ts, 2, 22)) +>y : Symbol(c.y, Decl(declFileTypeofClass.ts, 1, 22)) private x3: string; ->x3 : Symbol(c.x3, Decl(declFileTypeofClass.ts, 3, 29)) +>x3 : Symbol(c.x3, Decl(declFileTypeofClass.ts, 2, 29)) public y3: number; ->y3 : Symbol(c.y3, Decl(declFileTypeofClass.ts, 4, 23)) +>y3 : Symbol(c.y3, Decl(declFileTypeofClass.ts, 3, 23)) } var x: c; ->x : Symbol(x, Decl(declFileTypeofClass.ts, 8, 3)) +>x : Symbol(x, Decl(declFileTypeofClass.ts, 7, 3)) >c : Symbol(c, Decl(declFileTypeofClass.ts, 0, 0)) var y = c; ->y : Symbol(y, Decl(declFileTypeofClass.ts, 9, 3)) +>y : Symbol(y, Decl(declFileTypeofClass.ts, 8, 3)) >c : Symbol(c, Decl(declFileTypeofClass.ts, 0, 0)) var z: typeof c; ->z : Symbol(z, Decl(declFileTypeofClass.ts, 10, 3)) +>z : Symbol(z, Decl(declFileTypeofClass.ts, 9, 3)) >c : Symbol(c, Decl(declFileTypeofClass.ts, 0, 0)) class genericC ->genericC : Symbol(genericC, Decl(declFileTypeofClass.ts, 10, 16)) ->T : Symbol(T, Decl(declFileTypeofClass.ts, 11, 15)) +>genericC : Symbol(genericC, Decl(declFileTypeofClass.ts, 9, 16)) +>T : Symbol(T, Decl(declFileTypeofClass.ts, 10, 15)) { } var genericX = genericC; ->genericX : Symbol(genericX, Decl(declFileTypeofClass.ts, 14, 3)) ->genericC : Symbol(genericC, Decl(declFileTypeofClass.ts, 10, 16)) +>genericX : Symbol(genericX, Decl(declFileTypeofClass.ts, 13, 3)) +>genericC : Symbol(genericC, Decl(declFileTypeofClass.ts, 9, 16)) diff --git a/tests/baselines/reference/declFileTypeofClass.types b/tests/baselines/reference/declFileTypeofClass.types index 119ad9bb7d431..f2f71639f7fe9 100644 --- a/tests/baselines/reference/declFileTypeofClass.types +++ b/tests/baselines/reference/declFileTypeofClass.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofClass.ts === - class c { >c : c diff --git a/tests/baselines/reference/declFileTypeofEnum.js b/tests/baselines/reference/declFileTypeofEnum.js index 5b1c697747230..0e31a7c35114b 100644 --- a/tests/baselines/reference/declFileTypeofEnum.js +++ b/tests/baselines/reference/declFileTypeofEnum.js @@ -1,5 +1,4 @@ //// [declFileTypeofEnum.ts] - enum days { monday, tuesday, diff --git a/tests/baselines/reference/declFileTypeofEnum.symbols b/tests/baselines/reference/declFileTypeofEnum.symbols index 9980167788acd..bd1542242437e 100644 --- a/tests/baselines/reference/declFileTypeofEnum.symbols +++ b/tests/baselines/reference/declFileTypeofEnum.symbols @@ -1,41 +1,40 @@ === tests/cases/compiler/declFileTypeofEnum.ts === - enum days { >days : Symbol(days, Decl(declFileTypeofEnum.ts, 0, 0)) monday, ->monday : Symbol(days.monday, Decl(declFileTypeofEnum.ts, 1, 11)) +>monday : Symbol(days.monday, Decl(declFileTypeofEnum.ts, 0, 11)) tuesday, ->tuesday : Symbol(days.tuesday, Decl(declFileTypeofEnum.ts, 2, 11)) +>tuesday : Symbol(days.tuesday, Decl(declFileTypeofEnum.ts, 1, 11)) wednesday, ->wednesday : Symbol(days.wednesday, Decl(declFileTypeofEnum.ts, 3, 12)) +>wednesday : Symbol(days.wednesday, Decl(declFileTypeofEnum.ts, 2, 12)) thursday, ->thursday : Symbol(days.thursday, Decl(declFileTypeofEnum.ts, 4, 14)) +>thursday : Symbol(days.thursday, Decl(declFileTypeofEnum.ts, 3, 14)) friday, ->friday : Symbol(days.friday, Decl(declFileTypeofEnum.ts, 5, 13)) +>friday : Symbol(days.friday, Decl(declFileTypeofEnum.ts, 4, 13)) saturday, ->saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 6, 11)) +>saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 5, 11)) sunday ->sunday : Symbol(days.sunday, Decl(declFileTypeofEnum.ts, 7, 13)) +>sunday : Symbol(days.sunday, Decl(declFileTypeofEnum.ts, 6, 13)) } var weekendDay = days.saturday; ->weekendDay : Symbol(weekendDay, Decl(declFileTypeofEnum.ts, 11, 3)) ->days.saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 6, 11)) +>weekendDay : Symbol(weekendDay, Decl(declFileTypeofEnum.ts, 10, 3)) +>days.saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 5, 11)) >days : Symbol(days, Decl(declFileTypeofEnum.ts, 0, 0)) ->saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 6, 11)) +>saturday : Symbol(days.saturday, Decl(declFileTypeofEnum.ts, 5, 11)) var daysOfMonth = days; ->daysOfMonth : Symbol(daysOfMonth, Decl(declFileTypeofEnum.ts, 12, 3)) +>daysOfMonth : Symbol(daysOfMonth, Decl(declFileTypeofEnum.ts, 11, 3)) >days : Symbol(days, Decl(declFileTypeofEnum.ts, 0, 0)) var daysOfYear: typeof days; ->daysOfYear : Symbol(daysOfYear, Decl(declFileTypeofEnum.ts, 13, 3)) +>daysOfYear : Symbol(daysOfYear, Decl(declFileTypeofEnum.ts, 12, 3)) >days : Symbol(days, Decl(declFileTypeofEnum.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileTypeofEnum.types b/tests/baselines/reference/declFileTypeofEnum.types index 1d69d0594c8ba..b822cfa68d875 100644 --- a/tests/baselines/reference/declFileTypeofEnum.types +++ b/tests/baselines/reference/declFileTypeofEnum.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofEnum.ts === - enum days { >days : days diff --git a/tests/baselines/reference/declFileTypeofFunction.js b/tests/baselines/reference/declFileTypeofFunction.js index 656e02b8dddc3..ae1f1b0fcf207 100644 --- a/tests/baselines/reference/declFileTypeofFunction.js +++ b/tests/baselines/reference/declFileTypeofFunction.js @@ -1,5 +1,4 @@ //// [declFileTypeofFunction.ts] - function f(n: typeof f): string; function f(n: typeof g): string; function f() { return undefined; } diff --git a/tests/baselines/reference/declFileTypeofFunction.symbols b/tests/baselines/reference/declFileTypeofFunction.symbols index 649c09cba0662..cdab4ca0aa30e 100644 --- a/tests/baselines/reference/declFileTypeofFunction.symbols +++ b/tests/baselines/reference/declFileTypeofFunction.symbols @@ -1,82 +1,81 @@ === tests/cases/compiler/declFileTypeofFunction.ts === - function f(n: typeof f): string; ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) ->n : Symbol(n, Decl(declFileTypeofFunction.ts, 1, 11)) ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) +>n : Symbol(n, Decl(declFileTypeofFunction.ts, 0, 11)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) function f(n: typeof g): string; ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) ->n : Symbol(n, Decl(declFileTypeofFunction.ts, 2, 11)) ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) +>n : Symbol(n, Decl(declFileTypeofFunction.ts, 1, 11)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) function f() { return undefined; } ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) >undefined : Symbol(undefined) function g(n: typeof g): number; ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) ->n : Symbol(n, Decl(declFileTypeofFunction.ts, 4, 11)) ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) +>n : Symbol(n, Decl(declFileTypeofFunction.ts, 3, 11)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) function g(n: typeof f): number; ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) ->n : Symbol(n, Decl(declFileTypeofFunction.ts, 5, 11)) ->f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 1, 32), Decl(declFileTypeofFunction.ts, 2, 32)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) +>n : Symbol(n, Decl(declFileTypeofFunction.ts, 4, 11)) +>f : Symbol(f, Decl(declFileTypeofFunction.ts, 0, 0), Decl(declFileTypeofFunction.ts, 0, 32), Decl(declFileTypeofFunction.ts, 1, 32)) function g() { return undefined; } ->g : Symbol(g, Decl(declFileTypeofFunction.ts, 3, 34), Decl(declFileTypeofFunction.ts, 4, 32), Decl(declFileTypeofFunction.ts, 5, 32)) +>g : Symbol(g, Decl(declFileTypeofFunction.ts, 2, 34), Decl(declFileTypeofFunction.ts, 3, 32), Decl(declFileTypeofFunction.ts, 4, 32)) >undefined : Symbol(undefined) var b: () => typeof b; ->b : Symbol(b, Decl(declFileTypeofFunction.ts, 8, 3)) ->b : Symbol(b, Decl(declFileTypeofFunction.ts, 8, 3)) +>b : Symbol(b, Decl(declFileTypeofFunction.ts, 7, 3)) +>b : Symbol(b, Decl(declFileTypeofFunction.ts, 7, 3)) function b1() { ->b1 : Symbol(b1, Decl(declFileTypeofFunction.ts, 8, 22)) +>b1 : Symbol(b1, Decl(declFileTypeofFunction.ts, 7, 22)) return b1; ->b1 : Symbol(b1, Decl(declFileTypeofFunction.ts, 8, 22)) +>b1 : Symbol(b1, Decl(declFileTypeofFunction.ts, 7, 22)) } function foo(): typeof foo { ->foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 12, 1)) ->foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 12, 1)) +>foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 11, 1)) +>foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 11, 1)) return null; } var foo1: typeof foo; ->foo1 : Symbol(foo1, Decl(declFileTypeofFunction.ts, 17, 3)) ->foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 12, 1)) +>foo1 : Symbol(foo1, Decl(declFileTypeofFunction.ts, 16, 3)) +>foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 11, 1)) var foo2 = foo; ->foo2 : Symbol(foo2, Decl(declFileTypeofFunction.ts, 18, 3)) ->foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 12, 1)) +>foo2 : Symbol(foo2, Decl(declFileTypeofFunction.ts, 17, 3)) +>foo : Symbol(foo, Decl(declFileTypeofFunction.ts, 11, 1)) var foo3 = function () { ->foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 20, 3)) +>foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 19, 3)) return foo3; ->foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 20, 3)) +>foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 19, 3)) } var x = () => { ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 23, 3)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 22, 3)) return x; ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 23, 3)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 22, 3)) } function foo5(x: number) { ->foo5 : Symbol(foo5, Decl(declFileTypeofFunction.ts, 25, 1)) ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 27, 14)) +>foo5 : Symbol(foo5, Decl(declFileTypeofFunction.ts, 24, 1)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 26, 14)) function bar(x: number) { ->bar : Symbol(bar, Decl(declFileTypeofFunction.ts, 27, 26)) ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 28, 17)) +>bar : Symbol(bar, Decl(declFileTypeofFunction.ts, 26, 26)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 27, 17)) return x; ->x : Symbol(x, Decl(declFileTypeofFunction.ts, 28, 17)) +>x : Symbol(x, Decl(declFileTypeofFunction.ts, 27, 17)) } return bar; ->bar : Symbol(bar, Decl(declFileTypeofFunction.ts, 27, 26)) +>bar : Symbol(bar, Decl(declFileTypeofFunction.ts, 26, 26)) } diff --git a/tests/baselines/reference/declFileTypeofFunction.types b/tests/baselines/reference/declFileTypeofFunction.types index b47b07035d13b..fdc06020663ba 100644 --- a/tests/baselines/reference/declFileTypeofFunction.types +++ b/tests/baselines/reference/declFileTypeofFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofFunction.ts === - function f(n: typeof f): string; >f : { (n: typeof f): string; (n: { (n: typeof g): number; (n: typeof f): number; }): string; } >n : { (n: typeof f): string; (n: { (n: typeof g): number; (n: typeof f): number; }): string; } diff --git a/tests/baselines/reference/declFileTypeofInAnonymousType.js b/tests/baselines/reference/declFileTypeofInAnonymousType.js index 656cd49ebfaea..059812e9f49de 100644 --- a/tests/baselines/reference/declFileTypeofInAnonymousType.js +++ b/tests/baselines/reference/declFileTypeofInAnonymousType.js @@ -1,5 +1,4 @@ //// [declFileTypeofInAnonymousType.ts] - module m1 { export class c { } diff --git a/tests/baselines/reference/declFileTypeofInAnonymousType.symbols b/tests/baselines/reference/declFileTypeofInAnonymousType.symbols index 426f953d6f214..42f63de6341da 100644 --- a/tests/baselines/reference/declFileTypeofInAnonymousType.symbols +++ b/tests/baselines/reference/declFileTypeofInAnonymousType.symbols @@ -1,77 +1,76 @@ === tests/cases/compiler/declFileTypeofInAnonymousType.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) export class c { ->c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) } export enum e { ->e : Symbol(e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) +>e : Symbol(e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) weekday, ->weekday : Symbol(e.weekday, Decl(declFileTypeofInAnonymousType.ts, 4, 19)) +>weekday : Symbol(e.weekday, Decl(declFileTypeofInAnonymousType.ts, 3, 19)) weekend, ->weekend : Symbol(e.weekend, Decl(declFileTypeofInAnonymousType.ts, 5, 16)) +>weekend : Symbol(e.weekend, Decl(declFileTypeofInAnonymousType.ts, 4, 16)) holiday ->holiday : Symbol(e.holiday, Decl(declFileTypeofInAnonymousType.ts, 6, 16)) +>holiday : Symbol(e.holiday, Decl(declFileTypeofInAnonymousType.ts, 5, 16)) } } var a: { c: m1.c; }; ->a : Symbol(a, Decl(declFileTypeofInAnonymousType.ts, 10, 3)) ->c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 10, 8)) +>a : Symbol(a, Decl(declFileTypeofInAnonymousType.ts, 9, 3)) +>c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 9, 8)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) var b = { ->b : Symbol(b, Decl(declFileTypeofInAnonymousType.ts, 11, 3)) +>b : Symbol(b, Decl(declFileTypeofInAnonymousType.ts, 10, 3)) c: m1.c, ->c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 11, 9)) ->m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 10, 9)) +>m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) m1: m1 ->m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 12, 12)) +>m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 11, 12)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) }; var c = { m1: m1 }; ->c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 15, 3)) ->m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 15, 9)) +>c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 14, 3)) +>m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 14, 9)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) var d = { ->d : Symbol(d, Decl(declFileTypeofInAnonymousType.ts, 16, 3)) +>d : Symbol(d, Decl(declFileTypeofInAnonymousType.ts, 15, 3)) m: { mod: m1 }, ->m : Symbol(m, Decl(declFileTypeofInAnonymousType.ts, 16, 9)) ->mod : Symbol(mod, Decl(declFileTypeofInAnonymousType.ts, 17, 8)) +>m : Symbol(m, Decl(declFileTypeofInAnonymousType.ts, 15, 9)) +>mod : Symbol(mod, Decl(declFileTypeofInAnonymousType.ts, 16, 8)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) mc: { cl: m1.c }, ->mc : Symbol(mc, Decl(declFileTypeofInAnonymousType.ts, 17, 19)) ->cl : Symbol(cl, Decl(declFileTypeofInAnonymousType.ts, 18, 9)) ->m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>mc : Symbol(mc, Decl(declFileTypeofInAnonymousType.ts, 16, 19)) +>cl : Symbol(cl, Decl(declFileTypeofInAnonymousType.ts, 17, 9)) +>m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11)) +>c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 0, 11)) me: { en: m1.e }, ->me : Symbol(me, Decl(declFileTypeofInAnonymousType.ts, 18, 21)) ->en : Symbol(en, Decl(declFileTypeofInAnonymousType.ts, 19, 9)) ->m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) +>me : Symbol(me, Decl(declFileTypeofInAnonymousType.ts, 17, 21)) +>en : Symbol(en, Decl(declFileTypeofInAnonymousType.ts, 18, 9)) +>m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) +>e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) mh: m1.e.holiday ->mh : Symbol(mh, Decl(declFileTypeofInAnonymousType.ts, 19, 21)) ->m1.e.holiday : Symbol(m1.e.holiday, Decl(declFileTypeofInAnonymousType.ts, 6, 16)) ->m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) +>mh : Symbol(mh, Decl(declFileTypeofInAnonymousType.ts, 18, 21)) +>m1.e.holiday : Symbol(m1.e.holiday, Decl(declFileTypeofInAnonymousType.ts, 5, 16)) +>m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0)) ->e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5)) ->holiday : Symbol(m1.e.holiday, Decl(declFileTypeofInAnonymousType.ts, 6, 16)) +>e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 2, 5)) +>holiday : Symbol(m1.e.holiday, Decl(declFileTypeofInAnonymousType.ts, 5, 16)) }; diff --git a/tests/baselines/reference/declFileTypeofInAnonymousType.types b/tests/baselines/reference/declFileTypeofInAnonymousType.types index 2ab5e673fb244..2a3098b0859c3 100644 --- a/tests/baselines/reference/declFileTypeofInAnonymousType.types +++ b/tests/baselines/reference/declFileTypeofInAnonymousType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofInAnonymousType.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileTypeofModule.js b/tests/baselines/reference/declFileTypeofModule.js index fad0c1b25bba4..c5e268cb4fc59 100644 --- a/tests/baselines/reference/declFileTypeofModule.js +++ b/tests/baselines/reference/declFileTypeofModule.js @@ -1,5 +1,4 @@ //// [declFileTypeofModule.ts] - module m1 { export var c: string; } diff --git a/tests/baselines/reference/declFileTypeofModule.symbols b/tests/baselines/reference/declFileTypeofModule.symbols index c84185b105daf..feb99a6835649 100644 --- a/tests/baselines/reference/declFileTypeofModule.symbols +++ b/tests/baselines/reference/declFileTypeofModule.symbols @@ -1,32 +1,31 @@ === tests/cases/compiler/declFileTypeofModule.ts === - module m1 { >m1 : Symbol(m1, Decl(declFileTypeofModule.ts, 0, 0)) export var c: string; ->c : Symbol(c, Decl(declFileTypeofModule.ts, 2, 14)) +>c : Symbol(c, Decl(declFileTypeofModule.ts, 1, 14)) } var m1_1 = m1; ->m1_1 : Symbol(m1_1, Decl(declFileTypeofModule.ts, 4, 3)) +>m1_1 : Symbol(m1_1, Decl(declFileTypeofModule.ts, 3, 3)) >m1 : Symbol(m1, Decl(declFileTypeofModule.ts, 0, 0)) var m1_2: typeof m1; ->m1_2 : Symbol(m1_2, Decl(declFileTypeofModule.ts, 5, 3)) +>m1_2 : Symbol(m1_2, Decl(declFileTypeofModule.ts, 4, 3)) >m1 : Symbol(m1, Decl(declFileTypeofModule.ts, 0, 0)) module m2 { ->m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 5, 20)) +>m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 4, 20)) export var d: typeof m2; ->d : Symbol(d, Decl(declFileTypeofModule.ts, 8, 14)) ->m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 5, 20)) +>d : Symbol(d, Decl(declFileTypeofModule.ts, 7, 14)) +>m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 4, 20)) } var m2_1 = m2; ->m2_1 : Symbol(m2_1, Decl(declFileTypeofModule.ts, 11, 3)) ->m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 5, 20)) +>m2_1 : Symbol(m2_1, Decl(declFileTypeofModule.ts, 10, 3)) +>m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 4, 20)) var m2_2: typeof m2; ->m2_2 : Symbol(m2_2, Decl(declFileTypeofModule.ts, 12, 3)) ->m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 5, 20)) +>m2_2 : Symbol(m2_2, Decl(declFileTypeofModule.ts, 11, 3)) +>m2 : Symbol(m2, Decl(declFileTypeofModule.ts, 4, 20)) diff --git a/tests/baselines/reference/declFileTypeofModule.types b/tests/baselines/reference/declFileTypeofModule.types index ef4238bf2c59a..9b1b9b34832c6 100644 --- a/tests/baselines/reference/declFileTypeofModule.types +++ b/tests/baselines/reference/declFileTypeofModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileTypeofModule.ts === - module m1 { >m1 : typeof m1 diff --git a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.js b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.js index da1ebb2a8f3fb..ae82eec471484 100644 --- a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.js +++ b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.js @@ -1,5 +1,4 @@ //// [declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts] - declare module A.B.Base { export class W { id: number; diff --git a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.symbols b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.symbols index dd591277cd367..f7d0861925590 100644 --- a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.symbols +++ b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.symbols @@ -1,56 +1,55 @@ === tests/cases/compiler/declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts === - declare module A.B.Base { >A : Symbol(A, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 0)) ->B : Symbol(B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 17)) ->Base : Symbol(Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 19)) +>B : Symbol(B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 17)) +>Base : Symbol(Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 19)) export class W { ->W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 25)) +>W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 25)) id: number; ->id : Symbol(W.id, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 2, 20)) +>id : Symbol(W.id, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 20)) } } module X.Y.base { ->X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 11, 1)) ->Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 9)) ->base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 11)) +>X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 4, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 10, 1)) +>Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 9)) +>base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 11)) export class W extends A.B.Base.W { ->W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 17)) ->A.B.Base.W : Symbol(A.B.Base.W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 25)) ->A.B.Base : Symbol(A.B.Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 19)) ->A.B : Symbol(A.B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 17)) +>W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 17)) +>A.B.Base.W : Symbol(A.B.Base.W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 25)) +>A.B.Base : Symbol(A.B.Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 19)) +>A.B : Symbol(A.B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 17)) >A : Symbol(A, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 0)) ->B : Symbol(A.B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 17)) ->Base : Symbol(A.B.Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 19)) ->W : Symbol(A.B.Base.W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 1, 25)) +>B : Symbol(A.B, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 17)) +>Base : Symbol(A.B.Base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 19)) +>W : Symbol(A.B.Base.W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 0, 25)) name: string; ->name : Symbol(W.name, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 8, 39)) +>name : Symbol(W.name, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 7, 39)) } } module X.Y.base.Z { ->X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 11, 1)) ->Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 9)) ->base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 11)) ->Z : Symbol(Z, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 16)) +>X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 4, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 10, 1)) +>Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 9)) +>base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 11)) +>Z : Symbol(Z, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 16)) export class W extends X.Y.base.W { ->W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 19)) ->TValue : Symbol(TValue, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 15, 19)) ->X.Y.base.W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 17)) ->X.Y.base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 11)) ->X.Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 9)) ->X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 11, 1)) ->Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 9)) ->base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 13, 11)) ->W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 6, 17)) +>W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 19)) +>TValue : Symbol(TValue, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 14, 19)) +>X.Y.base.W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 17)) +>X.Y.base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 11)) +>X.Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 9)) +>X : Symbol(X, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 4, 1), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 10, 1)) +>Y : Symbol(Y, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 9), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 9)) +>base : Symbol(base, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 11), Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 12, 11)) +>W : Symbol(W, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 5, 17)) value: boolean; ->value : Symbol(W.value, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 15, 47)) +>value : Symbol(W.value, Decl(declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts, 14, 47)) } } diff --git a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.types b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.types index f032ad29b114c..339e8d7e1579d 100644 --- a/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.types +++ b/tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithClassNameConflictingWithClassReferredByExtendsClause.ts === - declare module A.B.Base { >A : typeof A >B : typeof B diff --git a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.errors.txt b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.errors.txt index 970133016183c..0cf59ee035bb9 100644 --- a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.errors.txt +++ b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.errors.txt @@ -1,7 +1,7 @@ +tests/cases/compiler/declFile.d.ts(2,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. tests/cases/compiler/declFile.d.ts(3,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(4,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(6,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(8,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/declFile.d.ts(5,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/declFile.d.ts(7,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. ==== tests/cases/compiler/client.ts (0 errors) ==== @@ -9,7 +9,6 @@ tests/cases/compiler/declFile.d.ts(8,5): error TS1038: A 'declare' modifier cann var x = new M.C(); // Declaration file wont get emitted because there are errors in declaration file ==== tests/cases/compiler/declFile.d.ts (4 errors) ==== - declare module M { declare var x; ~~~~~~~ diff --git a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.js b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.js index 30e80ef4e6f2c..a615e15584980 100644 --- a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.js +++ b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileWithErrorsInInputDeclarationFile.ts] //// //// [declFile.d.ts] - declare module M { declare var x; declare function f(); diff --git a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.errors.txt b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.errors.txt index 970133016183c..0cf59ee035bb9 100644 --- a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.errors.txt +++ b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.errors.txt @@ -1,7 +1,7 @@ +tests/cases/compiler/declFile.d.ts(2,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. tests/cases/compiler/declFile.d.ts(3,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(4,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(6,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/declFile.d.ts(8,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/declFile.d.ts(5,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/declFile.d.ts(7,5): error TS1038: A 'declare' modifier cannot be used in an already ambient context. ==== tests/cases/compiler/client.ts (0 errors) ==== @@ -9,7 +9,6 @@ tests/cases/compiler/declFile.d.ts(8,5): error TS1038: A 'declare' modifier cann var x = new M.C(); // Declaration file wont get emitted because there are errors in declaration file ==== tests/cases/compiler/declFile.d.ts (4 errors) ==== - declare module M { declare var x; ~~~~~~~ diff --git a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.js b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.js index 99dd625760f07..4ca4455ceb548 100644 --- a/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.js +++ b/tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declFileWithErrorsInInputDeclarationFileWithOut.ts] //// //// [declFile.d.ts] - declare module M { declare var x; declare function f(); diff --git a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.js b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.js index d369da3902b91..95ec6eeab32eb 100644 --- a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.js +++ b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.js @@ -1,5 +1,4 @@ //// [declFileWithExtendsClauseThatHasItsContainerNameConflict.ts] - declare module A.B.C { class B { } diff --git a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.symbols b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.symbols index 552a4a44b358d..125da03de550b 100644 --- a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.symbols +++ b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/declFileWithExtendsClauseThatHasItsContainerNameConflict.ts === - declare module A.B.C { ->A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 4, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 11, 1)) ->B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 9)) ->C : Symbol(C, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 19), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 11)) +>A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 3, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 10, 1)) +>B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 9)) +>C : Symbol(C, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 19), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 11)) class B { ->B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 22)) +>B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 22)) } } module A.B { ->A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 4, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 11, 1)) ->B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 9)) +>A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 3, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 10, 1)) +>B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 9)) export class EventManager { ->EventManager : Symbol(EventManager, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 12)) +>EventManager : Symbol(EventManager, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 12)) id: number; ->id : Symbol(EventManager.id, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 7, 31)) +>id : Symbol(EventManager.id, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 31)) } } module A.B.C { ->A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 4, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 11, 1)) ->B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 9)) ->C : Symbol(C, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 1, 19), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 11)) +>A : Symbol(A, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 0), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 3, 1), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 10, 1)) +>B : Symbol(B, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 17), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 9), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 9)) +>C : Symbol(C, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 0, 19), Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 11)) export class ContextMenu extends EventManager { ->ContextMenu : Symbol(ContextMenu, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 14)) ->EventManager : Symbol(EventManager, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 6, 12)) +>ContextMenu : Symbol(ContextMenu, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 12, 14)) +>EventManager : Symbol(EventManager, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 5, 12)) name: string; ->name : Symbol(ContextMenu.name, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 14, 51)) +>name : Symbol(ContextMenu.name, Decl(declFileWithExtendsClauseThatHasItsContainerNameConflict.ts, 13, 51)) } } diff --git a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.types b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.types index 4dae0d42c53ec..7564543097b88 100644 --- a/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.types +++ b/tests/baselines/reference/declFileWithExtendsClauseThatHasItsContainerNameConflict.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithExtendsClauseThatHasItsContainerNameConflict.ts === - declare module A.B.C { >A : typeof A >B : typeof B diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.js b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.js index 9b69ca88dc256..7b1690273207a 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.js +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.js @@ -1,5 +1,4 @@ //// [declFileWithInternalModuleNameConflictsInExtendsClause1.ts] - module X.A.C { export interface Z { } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.symbols b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.symbols index 15e9c6c6e852e..05110ee99eff6 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.symbols +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause1.ts === - module X.A.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 11)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 3, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 11)) export interface Z { ->Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 14)) +>Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 3, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 13)) module A { ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 16)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 16)) } export class W implements X.A.C.Z { // This needs to be refered as X.A.C.Z as A has conflict ->W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 7, 5)) ->X.A.C.Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 14)) ->X.A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 11)) ->X.A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 9)) ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 5, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 11)) ->Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 1, 14)) +>W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 6, 5)) +>X.A.C.Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 14)) +>X.A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 11)) +>X.A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 9)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 3, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 4, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 11)) +>Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause1.ts, 0, 14)) } } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.types b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.types index f6fb6dae29777..929f1ade1bf79 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.types +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause1.ts === - module X.A.C { >X : typeof X >A : typeof A diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.js b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.js index aa44c19444aef..b2dce928df77e 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.js +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.js @@ -1,5 +1,4 @@ //// [declFileWithInternalModuleNameConflictsInExtendsClause2.ts] - module X.A.C { export interface Z { } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.symbols b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.symbols index f0ce1ff2f97ff..3f716ab0472c4 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.symbols +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.symbols @@ -1,37 +1,36 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause2.ts === - module X.A.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 11)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 11)) export interface Z { ->Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 14)) +>Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 13)) export class W implements A.C.Z { // This can refer to it as A.C.Z ->W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 16)) ->A.C.Z : Symbol(A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 14)) ->A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 11)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 11)) ->Z : Symbol(A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 14)) +>W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 16)) +>A.C.Z : Symbol(A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 14)) +>A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 11)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 11)) +>Z : Symbol(A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 5, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 4, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 13)) module A { ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 10, 16)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause2.ts, 9, 16)) } } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.types b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.types index a59a69307439f..a244e2139e9fa 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.types +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause2.ts === - module X.A.C { >X : typeof X >A : typeof A diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.js b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.js index 164626db45a10..debc55565a139 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.js +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.js @@ -1,5 +1,4 @@ //// [declFileWithInternalModuleNameConflictsInExtendsClause3.ts] - module X.A.C { export interface Z { } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.symbols b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.symbols index 6d2a63b86ca91..e077f2a117047 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.symbols +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.symbols @@ -1,39 +1,38 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause3.ts === - module X.A.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 11)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 11)) export interface Z { ->Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 14)) +>Z : Symbol(Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 13)) export class W implements X.A.C.Z { // This needs to be refered as X.A.C.Z as A has conflict ->W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 16)) ->X.A.C.Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 14)) ->X.A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 11)) ->X.A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 11)) ->Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 14)) +>W : Symbol(W, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 16)) +>X.A.C.Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 14)) +>X.A.C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 11)) +>X.A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 11)) +>Z : Symbol(X.A.C.Z, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 14)) } } module X.A.B.C { ->X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 8, 1)) ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 1, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 9)) ->B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 11)) ->C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 5, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 13)) +>X : Symbol(X, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 0), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 3, 1), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 7, 1)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 0, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 9), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 9)) +>B : Symbol(B, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 11), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 11)) +>C : Symbol(C, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 4, 13), Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 13)) export module A { ->A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 10, 16)) +>A : Symbol(A, Decl(declFileWithInternalModuleNameConflictsInExtendsClause3.ts, 9, 16)) } } diff --git a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.types b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.types index f263cd96af81e..c94b408c939e0 100644 --- a/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.types +++ b/tests/baselines/reference/declFileWithInternalModuleNameConflictsInExtendsClause3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declFileWithInternalModuleNameConflictsInExtendsClause3.ts === - module X.A.C { >X : typeof X >A : typeof A diff --git a/tests/baselines/reference/declarationEmitBindingPatterns.js b/tests/baselines/reference/declarationEmitBindingPatterns.js index c55d885a1ca87..800e30032c680 100644 --- a/tests/baselines/reference/declarationEmitBindingPatterns.js +++ b/tests/baselines/reference/declarationEmitBindingPatterns.js @@ -1,5 +1,4 @@ //// [declarationEmitBindingPatterns.ts] - const k = ({x: z = 'y'}) => { } var a; diff --git a/tests/baselines/reference/declarationEmitBindingPatterns.symbols b/tests/baselines/reference/declarationEmitBindingPatterns.symbols index 705610bf04f0b..b3e011c16da41 100644 --- a/tests/baselines/reference/declarationEmitBindingPatterns.symbols +++ b/tests/baselines/reference/declarationEmitBindingPatterns.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/declarationEmitBindingPatterns.ts === - const k = ({x: z = 'y'}) => { } ->k : Symbol(k, Decl(declarationEmitBindingPatterns.ts, 1, 5)) +>k : Symbol(k, Decl(declarationEmitBindingPatterns.ts, 0, 5)) >x : Symbol(x) ->z : Symbol(z, Decl(declarationEmitBindingPatterns.ts, 1, 12)) +>z : Symbol(z, Decl(declarationEmitBindingPatterns.ts, 0, 12)) var a; ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) function f({} = a, [] = a, { p: {} = a} = a) { ->f : Symbol(f, Decl(declarationEmitBindingPatterns.ts, 3, 6)) ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) ->a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3)) +>f : Symbol(f, Decl(declarationEmitBindingPatterns.ts, 2, 6)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) +>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 2, 3)) } diff --git a/tests/baselines/reference/declarationEmitBindingPatterns.types b/tests/baselines/reference/declarationEmitBindingPatterns.types index a0ae3f5aa14e1..1a47fbebf07d8 100644 --- a/tests/baselines/reference/declarationEmitBindingPatterns.types +++ b/tests/baselines/reference/declarationEmitBindingPatterns.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitBindingPatterns.ts === - const k = ({x: z = 'y'}) => { } >k : ({x: z}: { x?: string; }) => void >({x: z = 'y'}) => { } : ({x: z}: { x?: string; }) => void diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict.js b/tests/baselines/reference/declarationEmitClassMemberNameConflict.js index 698622a86500f..200ca70d79f47 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict.js +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict.js @@ -1,5 +1,4 @@ //// [declarationEmitClassMemberNameConflict.ts] - export class C1 { C1() { } // has to be the same as the class name diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict.symbols b/tests/baselines/reference/declarationEmitClassMemberNameConflict.symbols index 02ea2f015f35d..d9cfd379f3d75 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict.symbols +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/declarationEmitClassMemberNameConflict.ts === - export class C1 { >C1 : Symbol(C1, Decl(declarationEmitClassMemberNameConflict.ts, 0, 0)) C1() { } // has to be the same as the class name ->C1 : Symbol(C1.C1, Decl(declarationEmitClassMemberNameConflict.ts, 1, 17)) +>C1 : Symbol(C1.C1, Decl(declarationEmitClassMemberNameConflict.ts, 0, 17)) bar() { ->bar : Symbol(C1.bar, Decl(declarationEmitClassMemberNameConflict.ts, 2, 12)) +>bar : Symbol(C1.bar, Decl(declarationEmitClassMemberNameConflict.ts, 1, 12)) return function (t: typeof C1) { ->t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 5, 25)) +>t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 4, 25)) >C1 : Symbol(C1, Decl(declarationEmitClassMemberNameConflict.ts, 0, 0)) }; @@ -18,52 +17,52 @@ export class C1 { } export class C2 { ->C2 : Symbol(C2, Decl(declarationEmitClassMemberNameConflict.ts, 8, 1)) +>C2 : Symbol(C2, Decl(declarationEmitClassMemberNameConflict.ts, 7, 1)) C2: any // has to be the same as the class name ->C2 : Symbol(C2.C2, Decl(declarationEmitClassMemberNameConflict.ts, 10, 17)) +>C2 : Symbol(C2.C2, Decl(declarationEmitClassMemberNameConflict.ts, 9, 17)) bar() { ->bar : Symbol(C2.bar, Decl(declarationEmitClassMemberNameConflict.ts, 11, 11)) +>bar : Symbol(C2.bar, Decl(declarationEmitClassMemberNameConflict.ts, 10, 11)) return function (t: typeof C2) { ->t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 14, 25)) ->C2 : Symbol(C2, Decl(declarationEmitClassMemberNameConflict.ts, 8, 1)) +>t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 13, 25)) +>C2 : Symbol(C2, Decl(declarationEmitClassMemberNameConflict.ts, 7, 1)) }; } } export class C3 { ->C3 : Symbol(C3, Decl(declarationEmitClassMemberNameConflict.ts, 17, 1)) +>C3 : Symbol(C3, Decl(declarationEmitClassMemberNameConflict.ts, 16, 1)) get C3() { return 0; } // has to be the same as the class name ->C3 : Symbol(C3.C3, Decl(declarationEmitClassMemberNameConflict.ts, 19, 17)) +>C3 : Symbol(C3.C3, Decl(declarationEmitClassMemberNameConflict.ts, 18, 17)) bar() { ->bar : Symbol(C3.bar, Decl(declarationEmitClassMemberNameConflict.ts, 20, 26)) +>bar : Symbol(C3.bar, Decl(declarationEmitClassMemberNameConflict.ts, 19, 26)) return function (t: typeof C3) { ->t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 23, 25)) ->C3 : Symbol(C3, Decl(declarationEmitClassMemberNameConflict.ts, 17, 1)) +>t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 22, 25)) +>C3 : Symbol(C3, Decl(declarationEmitClassMemberNameConflict.ts, 16, 1)) }; } } export class C4 { ->C4 : Symbol(C4, Decl(declarationEmitClassMemberNameConflict.ts, 26, 1)) +>C4 : Symbol(C4, Decl(declarationEmitClassMemberNameConflict.ts, 25, 1)) set C4(v) { } // has to be the same as the class name ->C4 : Symbol(C4.C4, Decl(declarationEmitClassMemberNameConflict.ts, 28, 17)) ->v : Symbol(v, Decl(declarationEmitClassMemberNameConflict.ts, 29, 11)) +>C4 : Symbol(C4.C4, Decl(declarationEmitClassMemberNameConflict.ts, 27, 17)) +>v : Symbol(v, Decl(declarationEmitClassMemberNameConflict.ts, 28, 11)) bar() { ->bar : Symbol(C4.bar, Decl(declarationEmitClassMemberNameConflict.ts, 29, 17)) +>bar : Symbol(C4.bar, Decl(declarationEmitClassMemberNameConflict.ts, 28, 17)) return function (t: typeof C4) { ->t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 32, 25)) ->C4 : Symbol(C4, Decl(declarationEmitClassMemberNameConflict.ts, 26, 1)) +>t : Symbol(t, Decl(declarationEmitClassMemberNameConflict.ts, 31, 25)) +>C4 : Symbol(C4, Decl(declarationEmitClassMemberNameConflict.ts, 25, 1)) }; } diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict.types b/tests/baselines/reference/declarationEmitClassMemberNameConflict.types index 266942f29c553..ab83212d0eb0a 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict.types +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitClassMemberNameConflict.ts === - export class C1 { >C1 : C1 diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.js b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.js index c5f8203a659e0..34ed145b6f3eb 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.js +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.js @@ -1,5 +1,4 @@ //// [declarationEmitClassMemberNameConflict2.ts] - const Bar = 'bar'; enum Hello { diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.symbols b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.symbols index 059200c6074bc..096ac556f9496 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.symbols +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.symbols @@ -1,37 +1,36 @@ === tests/cases/compiler/declarationEmitClassMemberNameConflict2.ts === - const Bar = 'bar'; ->Bar : Symbol(Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 1, 5)) +>Bar : Symbol(Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 0, 5)) enum Hello { ->Hello : Symbol(Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 1, 18)) +>Hello : Symbol(Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 0, 18)) World ->World : Symbol(Hello.World, Decl(declarationEmitClassMemberNameConflict2.ts, 3, 12)) +>World : Symbol(Hello.World, Decl(declarationEmitClassMemberNameConflict2.ts, 2, 12)) } enum Hello1 { ->Hello1 : Symbol(Hello1, Decl(declarationEmitClassMemberNameConflict2.ts, 5, 1)) +>Hello1 : Symbol(Hello1, Decl(declarationEmitClassMemberNameConflict2.ts, 4, 1)) World1 ->World1 : Symbol(Hello1.World1, Decl(declarationEmitClassMemberNameConflict2.ts, 7, 13)) +>World1 : Symbol(Hello1.World1, Decl(declarationEmitClassMemberNameConflict2.ts, 6, 13)) } class Foo { ->Foo : Symbol(Foo, Decl(declarationEmitClassMemberNameConflict2.ts, 9, 1)) +>Foo : Symbol(Foo, Decl(declarationEmitClassMemberNameConflict2.ts, 8, 1)) // Same names + string => OK Bar = Bar; ->Bar : Symbol(Foo.Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 11, 11)) ->Bar : Symbol(Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 1, 5)) +>Bar : Symbol(Foo.Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 10, 11)) +>Bar : Symbol(Bar, Decl(declarationEmitClassMemberNameConflict2.ts, 0, 5)) // Same names + enum => OK Hello = Hello; ->Hello : Symbol(Foo.Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 13, 14)) ->Hello : Symbol(Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 1, 18)) +>Hello : Symbol(Foo.Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 12, 14)) +>Hello : Symbol(Hello, Decl(declarationEmitClassMemberNameConflict2.ts, 0, 18)) // Different names + enum => OK Hello2 = Hello1; ->Hello2 : Symbol(Foo.Hello2, Decl(declarationEmitClassMemberNameConflict2.ts, 16, 18)) ->Hello1 : Symbol(Hello1, Decl(declarationEmitClassMemberNameConflict2.ts, 5, 1)) +>Hello2 : Symbol(Foo.Hello2, Decl(declarationEmitClassMemberNameConflict2.ts, 15, 18)) +>Hello1 : Symbol(Hello1, Decl(declarationEmitClassMemberNameConflict2.ts, 4, 1)) } diff --git a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.types b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.types index f355a9002c844..ede64818ff513 100644 --- a/tests/baselines/reference/declarationEmitClassMemberNameConflict2.types +++ b/tests/baselines/reference/declarationEmitClassMemberNameConflict2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitClassMemberNameConflict2.ts === - const Bar = 'bar'; >Bar : "bar" >'bar' : "bar" diff --git a/tests/baselines/reference/declarationEmitDefaultExport8.js b/tests/baselines/reference/declarationEmitDefaultExport8.js index c023f3be7d30e..5511c5981e51c 100644 --- a/tests/baselines/reference/declarationEmitDefaultExport8.js +++ b/tests/baselines/reference/declarationEmitDefaultExport8.js @@ -1,5 +1,4 @@ //// [declarationEmitDefaultExport8.ts] - var _default = 1; export {_default as d} export default 1 + 2; diff --git a/tests/baselines/reference/declarationEmitDefaultExport8.symbols b/tests/baselines/reference/declarationEmitDefaultExport8.symbols index be886b5a289af..b5bf1beaa9e39 100644 --- a/tests/baselines/reference/declarationEmitDefaultExport8.symbols +++ b/tests/baselines/reference/declarationEmitDefaultExport8.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/declarationEmitDefaultExport8.ts === - var _default = 1; ->_default : Symbol(_default, Decl(declarationEmitDefaultExport8.ts, 1, 3)) +>_default : Symbol(_default, Decl(declarationEmitDefaultExport8.ts, 0, 3)) export {_default as d} ->_default : Symbol(d, Decl(declarationEmitDefaultExport8.ts, 2, 8)) ->d : Symbol(d, Decl(declarationEmitDefaultExport8.ts, 2, 8)) +>_default : Symbol(d, Decl(declarationEmitDefaultExport8.ts, 1, 8)) +>d : Symbol(d, Decl(declarationEmitDefaultExport8.ts, 1, 8)) export default 1 + 2; diff --git a/tests/baselines/reference/declarationEmitDefaultExport8.types b/tests/baselines/reference/declarationEmitDefaultExport8.types index ed66a0fcb6f93..54de7b9839e48 100644 --- a/tests/baselines/reference/declarationEmitDefaultExport8.types +++ b/tests/baselines/reference/declarationEmitDefaultExport8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitDefaultExport8.ts === - var _default = 1; >_default : number >1 : 1 diff --git a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.js b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.js index 6b16d06cb8449..6ac6cf290182e 100644 --- a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.js +++ b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.js @@ -1,5 +1,4 @@ //// [pi.ts] - export default 3.14159; //// [app.js] diff --git a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.symbols b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.symbols index 82f52e818e355..a45ecb2e47e41 100644 --- a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.symbols +++ b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.symbols @@ -1,4 +1,3 @@ === tests/cases/compiler/pi.ts === - -No type information for this code.export default 3.14159; +export default 3.14159; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.types b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.types index 82f52e818e355..a45ecb2e47e41 100644 --- a/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.types +++ b/tests/baselines/reference/declarationEmitDefaultExportWithTempVarNameWithBundling.types @@ -1,4 +1,3 @@ === tests/cases/compiler/pi.ts === - -No type information for this code.export default 3.14159; +export default 3.14159; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.js b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.js index 9a9be8c69da32..6bd118e8f1cd0 100644 --- a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.js +++ b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringArrayPattern1.ts] - var [] = [1, "hello"]; // Dont emit anything var [x] = [1, "hello"]; // emit x: number var [x1, y1] = [1, "hello"]; // emit x1: number, y1: string diff --git a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.symbols b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.symbols index e9d80c89f6e39..8c954cb0d25e4 100644 --- a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.symbols +++ b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.symbols @@ -1,26 +1,25 @@ === tests/cases/compiler/declarationEmitDestructuringArrayPattern1.ts === - var [] = [1, "hello"]; // Dont emit anything var [x] = [1, "hello"]; // emit x: number ->x : Symbol(x, Decl(declarationEmitDestructuringArrayPattern1.ts, 2, 5)) +>x : Symbol(x, Decl(declarationEmitDestructuringArrayPattern1.ts, 1, 5)) var [x1, y1] = [1, "hello"]; // emit x1: number, y1: string ->x1 : Symbol(x1, Decl(declarationEmitDestructuringArrayPattern1.ts, 3, 5)) ->y1 : Symbol(y1, Decl(declarationEmitDestructuringArrayPattern1.ts, 3, 8)) +>x1 : Symbol(x1, Decl(declarationEmitDestructuringArrayPattern1.ts, 2, 5)) +>y1 : Symbol(y1, Decl(declarationEmitDestructuringArrayPattern1.ts, 2, 8)) var [, , z1] = [0, 1, 2]; // emit z1: number ->z1 : Symbol(z1, Decl(declarationEmitDestructuringArrayPattern1.ts, 4, 8)) +>z1 : Symbol(z1, Decl(declarationEmitDestructuringArrayPattern1.ts, 3, 8)) var a = [1, "hello"]; ->a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 6, 3)) +>a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 5, 3)) var [x2] = a; // emit x2: number | string ->x2 : Symbol(x2, Decl(declarationEmitDestructuringArrayPattern1.ts, 7, 5)) ->a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 6, 3)) +>x2 : Symbol(x2, Decl(declarationEmitDestructuringArrayPattern1.ts, 6, 5)) +>a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 5, 3)) var [x3, y3, z3] = a; // emit x3, y3, z3 ->x3 : Symbol(x3, Decl(declarationEmitDestructuringArrayPattern1.ts, 8, 5)) ->y3 : Symbol(y3, Decl(declarationEmitDestructuringArrayPattern1.ts, 8, 8)) ->z3 : Symbol(z3, Decl(declarationEmitDestructuringArrayPattern1.ts, 8, 12)) ->a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 6, 3)) +>x3 : Symbol(x3, Decl(declarationEmitDestructuringArrayPattern1.ts, 7, 5)) +>y3 : Symbol(y3, Decl(declarationEmitDestructuringArrayPattern1.ts, 7, 8)) +>z3 : Symbol(z3, Decl(declarationEmitDestructuringArrayPattern1.ts, 7, 12)) +>a : Symbol(a, Decl(declarationEmitDestructuringArrayPattern1.ts, 5, 3)) diff --git a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.types b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.types index 640062c07856d..c52b989346390 100644 --- a/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.types +++ b/tests/baselines/reference/declarationEmitDestructuringArrayPattern1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitDestructuringArrayPattern1.ts === - var [] = [1, "hello"]; // Dont emit anything >[1, "hello"] : (string | number)[] >1 : 1 diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt index 92a8cba2d4002..63b68a6fc6b7f 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(2,13): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(2,19): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{}'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(3,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(4,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(6,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(7,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(1,13): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(1,19): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{}'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(2,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(3,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(5,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts(6,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. ==== tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts (6 errors) ==== - var { } = { x: 5, y: "hello" }; ~ !!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.js b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.js index 38b0a14af5c97..0414017b776bd 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.js +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringObjectLiteralPattern.ts] - var { } = { x: 5, y: "hello" }; var { x4 } = { x4: 5, y4: "hello" }; var { y5 } = { x5: 5, y5: "hello" }; diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt index 24fbcf99ad1d7..bb8ec829b35f2 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(2,13): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(2,19): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{}'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(3,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(4,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(6,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. -tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(7,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(1,13): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(1,19): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{}'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(2,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(3,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(5,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. +tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts(6,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. ==== tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts (6 errors) ==== - var { } = { x: 5, y: "hello" }; ~ !!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.js b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.js index 264e56fe58c5c..1e8279597d595 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.js +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringObjectLiteralPattern1.ts] - var { } = { x: 5, y: "hello" }; var { x4 } = { x4: 5, y4: "hello" }; var { y5 } = { x5: 5, y5: "hello" }; diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.js b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.js index 7e5a3d9d2fa7c..6b8add193f230 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.js +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringObjectLiteralPattern2.ts] - var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: true } } }; function f15() { diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols index 77e26e2c9b7ed..2138ef896e09c 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols @@ -1,49 +1,48 @@ === tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern2.ts === - var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: true } } }; ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 46)) ->x11 : Symbol(x11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 5)) ->b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 52)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 57)) ->y11 : Symbol(y11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 18)) ->b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 69)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 74)) ->z11 : Symbol(z11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 31)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 46)) ->b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 52)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 57)) ->b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 69)) ->a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 74)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 46)) +>x11 : Symbol(x11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 5)) +>b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 52)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 57)) +>y11 : Symbol(y11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 18)) +>b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 69)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 74)) +>z11 : Symbol(z11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 31)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 46)) +>b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 52)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 57)) +>b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 69)) +>a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 74)) function f15() { ->f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 89)) +>f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 89)) var a4 = "hello"; ->a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 4, 7)) +>a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 3, 7)) var b4 = 1; ->b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 5, 7)) +>b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 4, 7)) var c4 = true; ->c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 7)) +>c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 5, 7)) return { a4, b4, c4 }; ->a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 12)) ->b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 16)) ->c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 20)) +>a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 12)) +>b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 16)) +>c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 20)) } var { a4, b4, c4 } = f15(); ->a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 9, 5)) ->b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 9, 9)) ->c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 9, 13)) ->f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 89)) +>a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 8, 5)) +>b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 8, 9)) +>c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 8, 13)) +>f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 89)) module m { ->m : Symbol(m, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 9, 27)) +>m : Symbol(m, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 8, 27)) export var { a4, b4, c4 } = f15(); ->a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 12, 16)) ->b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 12, 20)) ->c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 12, 24)) ->f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 89)) +>a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 11, 16)) +>b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 11, 20)) +>c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 11, 24)) +>f15 : Symbol(f15, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 0, 89)) } diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.types b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.types index f8f9a6a319cb9..a86976c0d1f40 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.types +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern2.ts === - var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: true } } }; >a : any >x11 : number diff --git a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.js b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.js index 941bb383f8135..c64148f8e508a 100644 --- a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.js +++ b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.js @@ -1,5 +1,4 @@ //// [declarationEmitDestructuringOptionalBindingParametersInOverloads.ts] - function foo([x, y, z] ?: [string, number, boolean]); function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.symbols b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.symbols index fbe26452476c6..1cfe2b72e87fb 100644 --- a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.symbols +++ b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.symbols @@ -1,27 +1,26 @@ === tests/cases/compiler/declarationEmitDestructuringOptionalBindingParametersInOverloads.ts === - function foo([x, y, z] ?: [string, number, boolean]); ->foo : Symbol(foo, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 0), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 53)) ->x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 14)) ->y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 16)) ->z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 19)) +>foo : Symbol(foo, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 0), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 53)) +>x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 14)) +>y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 16)) +>z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 19)) function foo(...rest: any[]) { ->foo : Symbol(foo, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 0), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 53)) ->rest : Symbol(rest, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 2, 13)) +>foo : Symbol(foo, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 0), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 0, 53)) +>rest : Symbol(rest, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 1, 13)) } function foo2( { x, y, z }?: { x: string; y: number; z: boolean }); ->foo2 : Symbol(foo2, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 3, 1), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 67)) ->x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 16)) ->y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 19)) ->z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 22)) ->x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 30)) ->y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 41)) ->z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 52)) +>foo2 : Symbol(foo2, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 2, 1), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 67)) +>x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 16)) +>y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 19)) +>z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 22)) +>x : Symbol(x, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 30)) +>y : Symbol(y, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 41)) +>z : Symbol(z, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 52)) function foo2(...rest: any[]) { ->foo2 : Symbol(foo2, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 3, 1), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 67)) ->rest : Symbol(rest, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 6, 14)) +>foo2 : Symbol(foo2, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 2, 1), Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 4, 67)) +>rest : Symbol(rest, Decl(declarationEmitDestructuringOptionalBindingParametersInOverloads.ts, 5, 14)) } diff --git a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types index 9eabfebe87795..0bf290bcf7dae 100644 --- a/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types +++ b/tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitDestructuringOptionalBindingParametersInOverloads.ts === - function foo([x, y, z] ?: [string, number, boolean]); >foo : ([x, y, z]?: [string, number, boolean]) => any >x : string diff --git a/tests/baselines/reference/declarationEmitDetachedComment1.js b/tests/baselines/reference/declarationEmitDetachedComment1.js index 6d3666d389d61..7f3bcea93c86f 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment1.js +++ b/tests/baselines/reference/declarationEmitDetachedComment1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitDetachedComment1.ts] //// //// [test1.ts] - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment1.symbols b/tests/baselines/reference/declarationEmitDetachedComment1.symbols index c466716ca4497..509c64c87dbe1 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment1.symbols +++ b/tests/baselines/reference/declarationEmitDetachedComment1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/test1.ts === - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment1.types b/tests/baselines/reference/declarationEmitDetachedComment1.types index 6d1a87b515139..26b72fd498360 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment1.types +++ b/tests/baselines/reference/declarationEmitDetachedComment1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test1.ts === - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment2.js b/tests/baselines/reference/declarationEmitDetachedComment2.js index e06872b5eab67..0874733e5327c 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment2.js +++ b/tests/baselines/reference/declarationEmitDetachedComment2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitDetachedComment2.ts] //// //// [test1.ts] - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment2.symbols b/tests/baselines/reference/declarationEmitDetachedComment2.symbols index c466716ca4497..509c64c87dbe1 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment2.symbols +++ b/tests/baselines/reference/declarationEmitDetachedComment2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/test1.ts === - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitDetachedComment2.types b/tests/baselines/reference/declarationEmitDetachedComment2.types index 6d1a87b515139..26b72fd498360 100644 --- a/tests/baselines/reference/declarationEmitDetachedComment2.types +++ b/tests/baselines/reference/declarationEmitDetachedComment2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test1.ts === - /*! Copyright 2015 MyCompany Inc. */ /** diff --git a/tests/baselines/reference/declarationEmitExportAssignment.js b/tests/baselines/reference/declarationEmitExportAssignment.js index 223376ef8ffd9..371e586f4d9cb 100644 --- a/tests/baselines/reference/declarationEmitExportAssignment.js +++ b/tests/baselines/reference/declarationEmitExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitExportAssignment.ts] //// //// [utils.ts] - export function foo() { } export function bar() { } export interface Buzz { } diff --git a/tests/baselines/reference/declarationEmitExportAssignment.symbols b/tests/baselines/reference/declarationEmitExportAssignment.symbols index d2131d27a8fcb..f03ce547dbb53 100644 --- a/tests/baselines/reference/declarationEmitExportAssignment.symbols +++ b/tests/baselines/reference/declarationEmitExportAssignment.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/utils.ts === - export function foo() { } >foo : Symbol(foo, Decl(utils.ts, 0, 0)) export function bar() { } ->bar : Symbol(bar, Decl(utils.ts, 1, 25)) +>bar : Symbol(bar, Decl(utils.ts, 0, 25)) export interface Buzz { } ->Buzz : Symbol(Buzz, Decl(utils.ts, 2, 25)) +>Buzz : Symbol(Buzz, Decl(utils.ts, 1, 25)) === tests/cases/compiler/index.ts === import {foo} from "./utils"; diff --git a/tests/baselines/reference/declarationEmitExportAssignment.types b/tests/baselines/reference/declarationEmitExportAssignment.types index 763441b8a9015..ee8db1950f231 100644 --- a/tests/baselines/reference/declarationEmitExportAssignment.types +++ b/tests/baselines/reference/declarationEmitExportAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/utils.ts === - export function foo() { } >foo : () => void diff --git a/tests/baselines/reference/declarationEmitExportDeclaration.js b/tests/baselines/reference/declarationEmitExportDeclaration.js index 57c39b95e6448..1cde34aeba0d2 100644 --- a/tests/baselines/reference/declarationEmitExportDeclaration.js +++ b/tests/baselines/reference/declarationEmitExportDeclaration.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitExportDeclaration.ts] //// //// [utils.ts] - export function foo() { } export function bar() { } export interface Buzz { } diff --git a/tests/baselines/reference/declarationEmitExportDeclaration.symbols b/tests/baselines/reference/declarationEmitExportDeclaration.symbols index 40d6bafdee515..3a63171377ea4 100644 --- a/tests/baselines/reference/declarationEmitExportDeclaration.symbols +++ b/tests/baselines/reference/declarationEmitExportDeclaration.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/utils.ts === - export function foo() { } >foo : Symbol(foo, Decl(utils.ts, 0, 0)) export function bar() { } ->bar : Symbol(bar, Decl(utils.ts, 1, 25)) +>bar : Symbol(bar, Decl(utils.ts, 0, 25)) export interface Buzz { } ->Buzz : Symbol(Buzz, Decl(utils.ts, 2, 25)) +>Buzz : Symbol(Buzz, Decl(utils.ts, 1, 25)) === tests/cases/compiler/index.ts === import {foo, bar, Buzz} from "./utils"; diff --git a/tests/baselines/reference/declarationEmitExportDeclaration.types b/tests/baselines/reference/declarationEmitExportDeclaration.types index 25a8f1d29bd31..1e52215aef3e0 100644 --- a/tests/baselines/reference/declarationEmitExportDeclaration.types +++ b/tests/baselines/reference/declarationEmitExportDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/utils.ts === - export function foo() { } >foo : () => void diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends.js b/tests/baselines/reference/declarationEmitExpressionInExtends.js index 884897a9cf629..2c659ce901866 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends.js +++ b/tests/baselines/reference/declarationEmitExpressionInExtends.js @@ -1,5 +1,4 @@ //// [declarationEmitExpressionInExtends.ts] - var x: { new(s: any): Q; } diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends.symbols b/tests/baselines/reference/declarationEmitExpressionInExtends.symbols index 8ae1e2928fdfe..157c82dd4ca8a 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends.symbols +++ b/tests/baselines/reference/declarationEmitExpressionInExtends.symbols @@ -1,32 +1,31 @@ === tests/cases/compiler/declarationEmitExpressionInExtends.ts === - var x: { ->x : Symbol(x, Decl(declarationEmitExpressionInExtends.ts, 1, 3)) +>x : Symbol(x, Decl(declarationEmitExpressionInExtends.ts, 0, 3)) new(s: any): Q; ->T : Symbol(T, Decl(declarationEmitExpressionInExtends.ts, 2, 8)) ->s : Symbol(s, Decl(declarationEmitExpressionInExtends.ts, 2, 11)) ->Q : Symbol(Q, Decl(declarationEmitExpressionInExtends.ts, 3, 1)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends.ts, 1, 8)) +>s : Symbol(s, Decl(declarationEmitExpressionInExtends.ts, 1, 11)) +>Q : Symbol(Q, Decl(declarationEmitExpressionInExtends.ts, 2, 1)) } class Q { ->Q : Symbol(Q, Decl(declarationEmitExpressionInExtends.ts, 3, 1)) +>Q : Symbol(Q, Decl(declarationEmitExpressionInExtends.ts, 2, 1)) s: string; ->s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 5, 9)) +>s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 4, 9)) } class B extends x { ->B : Symbol(B, Decl(declarationEmitExpressionInExtends.ts, 7, 1)) ->x : Symbol(x, Decl(declarationEmitExpressionInExtends.ts, 1, 3)) +>B : Symbol(B, Decl(declarationEmitExpressionInExtends.ts, 6, 1)) +>x : Symbol(x, Decl(declarationEmitExpressionInExtends.ts, 0, 3)) } var q: B; ->q : Symbol(q, Decl(declarationEmitExpressionInExtends.ts, 12, 3)) ->B : Symbol(B, Decl(declarationEmitExpressionInExtends.ts, 7, 1)) +>q : Symbol(q, Decl(declarationEmitExpressionInExtends.ts, 11, 3)) +>B : Symbol(B, Decl(declarationEmitExpressionInExtends.ts, 6, 1)) q.s; ->q.s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 5, 9)) ->q : Symbol(q, Decl(declarationEmitExpressionInExtends.ts, 12, 3)) ->s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 5, 9)) +>q.s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 4, 9)) +>q : Symbol(q, Decl(declarationEmitExpressionInExtends.ts, 11, 3)) +>s : Symbol(Q.s, Decl(declarationEmitExpressionInExtends.ts, 4, 9)) diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends.types b/tests/baselines/reference/declarationEmitExpressionInExtends.types index fdbec3f9c4896..a11312e225f5b 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends.types +++ b/tests/baselines/reference/declarationEmitExpressionInExtends.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitExpressionInExtends.ts === - var x: { >x : new (s: any) => Q diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends2.js b/tests/baselines/reference/declarationEmitExpressionInExtends2.js index 86c79dda8a811..301d935a1db2d 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends2.js +++ b/tests/baselines/reference/declarationEmitExpressionInExtends2.js @@ -1,5 +1,4 @@ //// [declarationEmitExpressionInExtends2.ts] - class C { x: T; y: U; diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends2.symbols b/tests/baselines/reference/declarationEmitExpressionInExtends2.symbols index a07590a14c7eb..28a6308d115c7 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends2.symbols +++ b/tests/baselines/reference/declarationEmitExpressionInExtends2.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/declarationEmitExpressionInExtends2.ts === - class C { >C : Symbol(C, Decl(declarationEmitExpressionInExtends2.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 1, 8)) ->U : Symbol(U, Decl(declarationEmitExpressionInExtends2.ts, 1, 10)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 0, 8)) +>U : Symbol(U, Decl(declarationEmitExpressionInExtends2.ts, 0, 10)) x: T; ->x : Symbol(C.x, Decl(declarationEmitExpressionInExtends2.ts, 1, 15)) ->T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 1, 8)) +>x : Symbol(C.x, Decl(declarationEmitExpressionInExtends2.ts, 0, 15)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 0, 8)) y: U; ->y : Symbol(C.y, Decl(declarationEmitExpressionInExtends2.ts, 2, 9)) ->U : Symbol(U, Decl(declarationEmitExpressionInExtends2.ts, 1, 10)) +>y : Symbol(C.y, Decl(declarationEmitExpressionInExtends2.ts, 1, 9)) +>U : Symbol(U, Decl(declarationEmitExpressionInExtends2.ts, 0, 10)) } function getClass(c: T) { ->getClass : Symbol(getClass, Decl(declarationEmitExpressionInExtends2.ts, 4, 1)) ->T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 6, 18)) ->c : Symbol(c, Decl(declarationEmitExpressionInExtends2.ts, 6, 21)) ->T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 6, 18)) +>getClass : Symbol(getClass, Decl(declarationEmitExpressionInExtends2.ts, 3, 1)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 5, 18)) +>c : Symbol(c, Decl(declarationEmitExpressionInExtends2.ts, 5, 21)) +>T : Symbol(T, Decl(declarationEmitExpressionInExtends2.ts, 5, 18)) return C; >C : Symbol(C, Decl(declarationEmitExpressionInExtends2.ts, 0, 0)) } class MyClass extends getClass(2) { ->MyClass : Symbol(MyClass, Decl(declarationEmitExpressionInExtends2.ts, 8, 1)) ->getClass : Symbol(getClass, Decl(declarationEmitExpressionInExtends2.ts, 4, 1)) +>MyClass : Symbol(MyClass, Decl(declarationEmitExpressionInExtends2.ts, 7, 1)) +>getClass : Symbol(getClass, Decl(declarationEmitExpressionInExtends2.ts, 3, 1)) } diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends2.types b/tests/baselines/reference/declarationEmitExpressionInExtends2.types index 04265e9f74ea7..435c0e8dbf8cd 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends2.types +++ b/tests/baselines/reference/declarationEmitExpressionInExtends2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitExpressionInExtends2.ts === - class C { >C : C >T : T diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends3.errors.txt b/tests/baselines/reference/declarationEmitExpressionInExtends3.errors.txt index 8bc4d9ac8d291..636085215acaf 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends3.errors.txt +++ b/tests/baselines/reference/declarationEmitExpressionInExtends3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/declarationEmitExpressionInExtends3.ts(29,30): error TS4020: 'extends' clause of exported class 'MyClass' has or is using private name 'LocalClass'. -tests/cases/compiler/declarationEmitExpressionInExtends3.ts(37,31): error TS4020: 'extends' clause of exported class 'MyClass3' has or is using private name 'LocalInterface'. +tests/cases/compiler/declarationEmitExpressionInExtends3.ts(28,30): error TS4020: 'extends' clause of exported class 'MyClass' has or is using private name 'LocalClass'. +tests/cases/compiler/declarationEmitExpressionInExtends3.ts(36,31): error TS4020: 'extends' clause of exported class 'MyClass3' has or is using private name 'LocalInterface'. ==== tests/cases/compiler/declarationEmitExpressionInExtends3.ts (2 errors) ==== - export class ExportedClass { x: T; } diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends3.js b/tests/baselines/reference/declarationEmitExpressionInExtends3.js index a02eac46dba20..7cc58772ec23f 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends3.js +++ b/tests/baselines/reference/declarationEmitExpressionInExtends3.js @@ -1,5 +1,4 @@ //// [declarationEmitExpressionInExtends3.ts] - export class ExportedClass { x: T; } diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends4.errors.txt b/tests/baselines/reference/declarationEmitExpressionInExtends4.errors.txt index 127f71ff353c8..b2e3eb58d54a2 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends4.errors.txt +++ b/tests/baselines/reference/declarationEmitExpressionInExtends4.errors.txt @@ -1,14 +1,13 @@ -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(2,10): error TS4060: Return type of exported function has or is using private name 'D'. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(6,7): error TS4093: 'extends' clause of exported class 'C' refers to a type whose name cannot be referenced. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(6,17): error TS2315: Type 'D' is not generic. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(10,7): error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(10,18): error TS2304: Cannot find name 'SomeUndefinedFunction'. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(15,18): error TS2304: Cannot find name 'SomeUndefinedFunction'. -tests/cases/compiler/declarationEmitExpressionInExtends4.ts(15,18): error TS4020: 'extends' clause of exported class 'C3' has or is using private name 'SomeUndefinedFunction'. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(1,10): error TS4060: Return type of exported function has or is using private name 'D'. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(5,7): error TS4093: 'extends' clause of exported class 'C' refers to a type whose name cannot be referenced. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(5,17): error TS2315: Type 'D' is not generic. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(9,7): error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(9,18): error TS2304: Cannot find name 'SomeUndefinedFunction'. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(14,18): error TS2304: Cannot find name 'SomeUndefinedFunction'. +tests/cases/compiler/declarationEmitExpressionInExtends4.ts(14,18): error TS4020: 'extends' clause of exported class 'C3' has or is using private name 'SomeUndefinedFunction'. ==== tests/cases/compiler/declarationEmitExpressionInExtends4.ts (7 errors) ==== - function getSomething() { ~~~~~~~~~~~~ !!! error TS4060: Return type of exported function has or is using private name 'D'. diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends4.js b/tests/baselines/reference/declarationEmitExpressionInExtends4.js index d6c33023c12df..4acfff77831b5 100644 --- a/tests/baselines/reference/declarationEmitExpressionInExtends4.js +++ b/tests/baselines/reference/declarationEmitExpressionInExtends4.js @@ -1,5 +1,4 @@ //// [declarationEmitExpressionInExtends4.ts] - function getSomething() { return class D { } } diff --git a/tests/baselines/reference/declarationEmitFBoundedTypeParams.js b/tests/baselines/reference/declarationEmitFBoundedTypeParams.js index 407dbf395e577..056ed423d5cda 100644 --- a/tests/baselines/reference/declarationEmitFBoundedTypeParams.js +++ b/tests/baselines/reference/declarationEmitFBoundedTypeParams.js @@ -1,5 +1,4 @@ //// [declarationEmitFBoundedTypeParams.ts] - // Repro from #6040 function append(result: a[], value: b): a[] { diff --git a/tests/baselines/reference/declarationEmitFBoundedTypeParams.symbols b/tests/baselines/reference/declarationEmitFBoundedTypeParams.symbols index bb12ea8960025..b90516af3b18f 100644 --- a/tests/baselines/reference/declarationEmitFBoundedTypeParams.symbols +++ b/tests/baselines/reference/declarationEmitFBoundedTypeParams.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/declarationEmitFBoundedTypeParams.ts === - // Repro from #6040 function append(result: a[], value: b): a[] { >append : Symbol(append, Decl(declarationEmitFBoundedTypeParams.ts, 0, 0)) ->a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 3, 16)) ->b : Symbol(b, Decl(declarationEmitFBoundedTypeParams.ts, 3, 18)) ->a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 3, 16)) ->result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 3, 32)) ->a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 3, 16)) ->value : Symbol(value, Decl(declarationEmitFBoundedTypeParams.ts, 3, 44)) ->b : Symbol(b, Decl(declarationEmitFBoundedTypeParams.ts, 3, 18)) ->a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 3, 16)) +>a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 2, 16)) +>b : Symbol(b, Decl(declarationEmitFBoundedTypeParams.ts, 2, 18)) +>a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 2, 16)) +>result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 2, 32)) +>a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 2, 16)) +>value : Symbol(value, Decl(declarationEmitFBoundedTypeParams.ts, 2, 44)) +>b : Symbol(b, Decl(declarationEmitFBoundedTypeParams.ts, 2, 18)) +>a : Symbol(a, Decl(declarationEmitFBoundedTypeParams.ts, 2, 16)) result.push(value); >result.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 3, 32)) +>result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 2, 32)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(declarationEmitFBoundedTypeParams.ts, 3, 44)) +>value : Symbol(value, Decl(declarationEmitFBoundedTypeParams.ts, 2, 44)) return result; ->result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 3, 32)) +>result : Symbol(result, Decl(declarationEmitFBoundedTypeParams.ts, 2, 32)) } diff --git a/tests/baselines/reference/declarationEmitFBoundedTypeParams.types b/tests/baselines/reference/declarationEmitFBoundedTypeParams.types index 7f7198b3b6d5c..80d1c80855d43 100644 --- a/tests/baselines/reference/declarationEmitFBoundedTypeParams.types +++ b/tests/baselines/reference/declarationEmitFBoundedTypeParams.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitFBoundedTypeParams.ts === - // Repro from #6040 function append(result: a[], value: b): a[] { diff --git a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.js b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.js index b2bca641a5a33..327a0befe6a72 100644 --- a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.js +++ b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.js @@ -1,5 +1,4 @@ //// [declarationEmitFirstTypeArgumentGenericFunctionType.ts] - class X { } var prop11: X< () => Tany >; // spaces before the first type argument diff --git a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.symbols b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.symbols index ebbc2b764b025..d820821dbdd8c 100644 --- a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.symbols +++ b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.symbols @@ -1,81 +1,80 @@ === tests/cases/compiler/declarationEmitFirstTypeArgumentGenericFunctionType.ts === - class X { >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->A : Symbol(A, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 1, 8)) +>A : Symbol(A, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 8)) } var prop11: X< () => Tany >; // spaces before the first type argument ->prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) +>prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 3)) >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 16)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 16)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 16)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 16)) var prop12: X<(() => Tany)>; // spaces before the first type argument ->prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 3)) +>prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 16)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 16)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 16)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 16)) function f1() { // Inferred return type ->f1 : Symbol(f1, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 34)) +>f1 : Symbol(f1, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 34)) return prop11; ->prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) +>prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 3)) } function f2() { // Inferred return type ->f2 : Symbol(f2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 7, 1)) +>f2 : Symbol(f2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 6, 1)) return prop12; ->prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 3)) +>prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) } function f3(): X< () => Tany> { // written with space before type argument ->f3 : Symbol(f3, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 10, 1)) +>f3 : Symbol(f3, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 9, 1)) >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 11, 19)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 11, 19)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 10, 19)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 10, 19)) return prop11; ->prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) +>prop11 : Symbol(prop11, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 2, 3)) } function f4(): X<(() => Tany)> { // written type with parenthesis ->f4 : Symbol(f4, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 13, 1)) +>f4 : Symbol(f4, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 12, 1)) >X : Symbol(X, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 0, 0)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 14, 19)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 14, 19)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 13, 19)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 13, 19)) return prop12; ->prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 4, 3)) +>prop12 : Symbol(prop12, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 3, 3)) } class Y { ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->A : Symbol(A, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 17, 8)) ->B : Symbol(B, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 17, 10)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>A : Symbol(A, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 8)) +>B : Symbol(B, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 10)) } var prop2: Y() => Tany>; // No space after second type argument ->prop2 : Symbol(prop2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 3), Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 3)) ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 24)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 24)) +>prop2 : Symbol(prop2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 18, 3), Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 3)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 18, 24)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 18, 24)) var prop2: Y() => Tany>; // space after second type argument ->prop2 : Symbol(prop2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 3), Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 3)) ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 24)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 24)) +>prop2 : Symbol(prop2, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 18, 3), Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 3)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 24)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 19, 24)) var prop3: Y< () => Tany, () => Tany>; // space before first type argument ->prop3 : Symbol(prop3, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 3)) ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 15)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 15)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 33)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 33)) +>prop3 : Symbol(prop3, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 3)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 15)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 15)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 33)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 20, 33)) var prop4: Y<(() => Tany), () => Tany>; // parenthesized first type argument ->prop4 : Symbol(prop4, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 3)) ->Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 16, 1)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 15)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 15)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 34)) ->Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 22, 34)) +>prop4 : Symbol(prop4, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 3)) +>Y : Symbol(Y, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 15, 1)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 15)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 15)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 34)) +>Tany : Symbol(Tany, Decl(declarationEmitFirstTypeArgumentGenericFunctionType.ts, 21, 34)) diff --git a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.types b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.types index 4dd6ecba98773..6fbff14492c2f 100644 --- a/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.types +++ b/tests/baselines/reference/declarationEmitFirstTypeArgumentGenericFunctionType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitFirstTypeArgumentGenericFunctionType.ts === - class X { >X : X >A : A diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicates01.js b/tests/baselines/reference/declarationEmitIdentifierPredicates01.js index 08208c2435d38..5bf62608fb81e 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicates01.js +++ b/tests/baselines/reference/declarationEmitIdentifierPredicates01.js @@ -1,5 +1,4 @@ //// [declarationEmitIdentifierPredicates01.ts] - export function f(x: any): x is number { return typeof x === "number"; } diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicates01.symbols b/tests/baselines/reference/declarationEmitIdentifierPredicates01.symbols index eb8b1151ceb96..5078fccedbcc0 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicates01.symbols +++ b/tests/baselines/reference/declarationEmitIdentifierPredicates01.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicates01.ts === - export function f(x: any): x is number { >f : Symbol(f, Decl(declarationEmitIdentifierPredicates01.ts, 0, 0)) ->x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 1, 18)) ->x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 1, 18)) +>x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 0, 18)) +>x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 0, 18)) return typeof x === "number"; ->x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 1, 18)) +>x : Symbol(x, Decl(declarationEmitIdentifierPredicates01.ts, 0, 18)) } diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicates01.types b/tests/baselines/reference/declarationEmitIdentifierPredicates01.types index 1aeb3ea824d67..6699e3fa23474 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicates01.types +++ b/tests/baselines/reference/declarationEmitIdentifierPredicates01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicates01.ts === - export function f(x: any): x is number { >f : (x: any) => x is number >x : any diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.errors.txt b/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.errors.txt index e9084c454906e..37a4853b6496f 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.errors.txt +++ b/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicatesWithPrivateName01.ts(6,33): error TS4060: Return type of exported function has or is using private name 'I'. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicatesWithPrivateName01.ts(5,33): error TS4060: Return type of exported function has or is using private name 'I'. ==== tests/cases/conformance/declarationEmit/typePredicates/declarationEmitIdentifierPredicatesWithPrivateName01.ts (1 errors) ==== - interface I { a: number; } diff --git a/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.js b/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.js index 5829e9b4427f0..74da01ce683ca 100644 --- a/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.js +++ b/tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.js @@ -1,5 +1,4 @@ //// [declarationEmitIdentifierPredicatesWithPrivateName01.ts] - interface I { a: number; } diff --git a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.js b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.js index a60b35c73abee..f9137f4f02b49 100644 --- a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.js +++ b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.js @@ -1,5 +1,4 @@ //// [declarationEmitImportInExportAssignmentModule.ts] - module m { export module c { export class c { diff --git a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.symbols b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.symbols index c4c92d547f30a..8abdc855d8e70 100644 --- a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.symbols +++ b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/declarationEmitImportInExportAssignmentModule.ts === - module m { >m : Symbol(m, Decl(declarationEmitImportInExportAssignmentModule.ts, 0, 0)) export module c { ->c : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 1, 10)) +>c : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 0, 10)) export class c { ->c : Symbol(c, Decl(declarationEmitImportInExportAssignmentModule.ts, 2, 21)) +>c : Symbol(c, Decl(declarationEmitImportInExportAssignmentModule.ts, 1, 21)) } } import x = c; ->x : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 5, 5)) ->c : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 1, 10)) +>x : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 4, 5)) +>c : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 0, 10)) export var a: typeof x; ->a : Symbol(a, Decl(declarationEmitImportInExportAssignmentModule.ts, 7, 14)) ->x : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 5, 5)) +>a : Symbol(a, Decl(declarationEmitImportInExportAssignmentModule.ts, 6, 14)) +>x : Symbol(x, Decl(declarationEmitImportInExportAssignmentModule.ts, 4, 5)) } export = m; >m : Symbol(m, Decl(declarationEmitImportInExportAssignmentModule.ts, 0, 0)) diff --git a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.types b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.types index 23176a0abe2e1..8cf124a92ceb1 100644 --- a/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.types +++ b/tests/baselines/reference/declarationEmitImportInExportAssignmentModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitImportInExportAssignmentModule.ts === - module m { >m : typeof m diff --git a/tests/baselines/reference/declarationEmitIndexTypeNotFound.errors.txt b/tests/baselines/reference/declarationEmitIndexTypeNotFound.errors.txt index ffbfd25fa949f..435ddd7c069e7 100644 --- a/tests/baselines/reference/declarationEmitIndexTypeNotFound.errors.txt +++ b/tests/baselines/reference/declarationEmitIndexTypeNotFound.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(3,6): error TS1023: An index signature parameter type must be 'string' or 'number'. -tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(3,13): error TS2304: Cannot find name 'TypeNotFound'. -tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(3,13): error TS4092: Parameter 'index' of index signature from exported interface has or is using private name 'TypeNotFound'. +tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(2,6): error TS1023: An index signature parameter type must be 'string' or 'number'. +tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(2,13): error TS2304: Cannot find name 'TypeNotFound'. +tests/cases/compiler/declarationEmitIndexTypeNotFound.ts(2,13): error TS4092: Parameter 'index' of index signature from exported interface has or is using private name 'TypeNotFound'. ==== tests/cases/compiler/declarationEmitIndexTypeNotFound.ts (3 errors) ==== - export interface Test { [index: TypeNotFound]: any; ~~~~~ diff --git a/tests/baselines/reference/declarationEmitIndexTypeNotFound.js b/tests/baselines/reference/declarationEmitIndexTypeNotFound.js index b1fac7c3cc238..f28f33f88e6f0 100644 --- a/tests/baselines/reference/declarationEmitIndexTypeNotFound.js +++ b/tests/baselines/reference/declarationEmitIndexTypeNotFound.js @@ -1,5 +1,4 @@ //// [declarationEmitIndexTypeNotFound.ts] - export interface Test { [index: TypeNotFound]: any; } diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType.js b/tests/baselines/reference/declarationEmitInferedDefaultExportType.js index 608f172cd1f7f..4d9eb47641a99 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType.js +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedDefaultExportType.ts] - // test.ts export default { foo: [], diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType.symbols b/tests/baselines/reference/declarationEmitInferedDefaultExportType.symbols index bf96810f78a3d..5d49c84e8f8fb 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType.symbols +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/declarationEmitInferedDefaultExportType.ts === - // test.ts export default { foo: [], ->foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType.ts, 2, 16)) +>foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType.ts, 1, 16)) bar: undefined, ->bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType.ts, 3, 10)) +>bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType.ts, 2, 10)) >undefined : Symbol(undefined) baz: null ->baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType.ts, 4, 17)) +>baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType.ts, 3, 17)) } diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType.types b/tests/baselines/reference/declarationEmitInferedDefaultExportType.types index 5c01d22b32ea9..4ccb520b60608 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType.types +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedDefaultExportType.ts === - // test.ts export default { >{ foo: [], bar: undefined, baz: null} : { foo: undefined[]; bar: undefined; baz: null; } diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.js b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.js index a81c7fc0bb775..96c16829d7e45 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.js +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedDefaultExportType2.ts] - // test.ts export = { foo: [], diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.symbols b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.symbols index 7ae974cca058b..8a617715bf417 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.symbols +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/declarationEmitInferedDefaultExportType2.ts === - // test.ts export = { foo: [], ->foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType2.ts, 2, 10)) +>foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType2.ts, 1, 10)) bar: undefined, ->bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType2.ts, 3, 10)) +>bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType2.ts, 2, 10)) >undefined : Symbol(undefined) baz: null ->baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType2.ts, 4, 17)) +>baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType2.ts, 3, 17)) } diff --git a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.types b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.types index a334434ea4518..808a0cf1e8514 100644 --- a/tests/baselines/reference/declarationEmitInferedDefaultExportType2.types +++ b/tests/baselines/reference/declarationEmitInferedDefaultExportType2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedDefaultExportType2.ts === - // test.ts export = { >{ foo: [], bar: undefined, baz: null} : { foo: undefined[]; bar: undefined; baz: null; } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias1.js b/tests/baselines/reference/declarationEmitInferedTypeAlias1.js index 4e41c8558c697..091e7f97a0efe 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias1.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias1.ts] //// //// [0.ts] - { type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols index 94599418c5d7b..3f49ebf17f7a1 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 3, 7)) ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>obj : Symbol(obj, Decl(0.ts, 2, 7)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) } export { } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias1.types b/tests/baselines/reference/declarationEmitInferedTypeAlias1.types index 922eb9ccf4422..7ea5f6ff2282c 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias1.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; >Data : string | boolean diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias2.js b/tests/baselines/reference/declarationEmitInferedTypeAlias2.js index 601026ab6f3bf..d99a1abc34621 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias2.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias2.ts] //// //// [0.ts] - { type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols index c8027397869b1..6494c8d8e8214 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 3, 7)) ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>obj : Symbol(obj, Decl(0.ts, 2, 7)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) } export { } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias2.types b/tests/baselines/reference/declarationEmitInferedTypeAlias2.types index 6a9ace4eb86d0..058c57a5c03c4 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias2.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; >Data : string | boolean diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias3.js b/tests/baselines/reference/declarationEmitInferedTypeAlias3.js index 30df7e38b0139..4621aa8db2fa1 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias3.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias3.ts] //// //// [0.ts] - { type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols index 8a9f7b35d1895..916ce781a2890 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 3, 7)) ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>obj : Symbol(obj, Decl(0.ts, 2, 7)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) } export { } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias3.types b/tests/baselines/reference/declarationEmitInferedTypeAlias3.types index 565a484a094e9..aa8fcf9eae132 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias3.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; >Data : string | boolean diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias4.js b/tests/baselines/reference/declarationEmitInferedTypeAlias4.js index 8d7ef72012cb7..c29dbb517d980 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias4.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias4.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedTypeAlias4.ts] - function f() { type Foo = T | { x: Foo }; var x: Foo; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols index f522eca7d0bd0..6108e2326d0ef 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias4.ts === - function f() { >f : Symbol(f, Decl(declarationEmitInferedTypeAlias4.ts, 0, 0)) ->A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 1, 11)) +>A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 0, 11)) type Foo = T | { x: Foo }; ->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13)) ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 23)) ->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13)) +>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 0, 17)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 1, 13)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 1, 13)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 1, 23)) +>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 0, 17)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 1, 13)) var x: Foo; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 3, 7)) ->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17)) ->A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 1, 11)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 7)) +>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 0, 17)) +>A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 0, 11)) return x; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 3, 7)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 7)) } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias4.types b/tests/baselines/reference/declarationEmitInferedTypeAlias4.types index f4cc0789f45bc..b4e5428e82a06 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias4.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias4.ts === - function f() { >f : () => A[] | { x: A[] | any; } >A : A diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias5.js b/tests/baselines/reference/declarationEmitInferedTypeAlias5.js index 24f2a52c5d8ea..a20c4da52e099 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias5.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias5.ts] //// //// [0.ts] - export type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols index 6c06697cfdc26..8c904c87c9b9f 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/0.ts === - export type Data = string | boolean; >Data : Symbol(Data, Decl(0.ts, 0, 0)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 2, 3)) +>obj : Symbol(obj, Decl(0.ts, 1, 3)) >Data : Symbol(Data, Decl(0.ts, 0, 0)) === tests/cases/compiler/1.ts === diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias5.types b/tests/baselines/reference/declarationEmitInferedTypeAlias5.types index 21e6b415d2e4d..d6d3ae7443e49 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias5.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - export type Data = string | boolean; >Data : Data diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias6.js b/tests/baselines/reference/declarationEmitInferedTypeAlias6.js index 5b14a3738e413..0b98e0bdeb03b 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias6.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias6.ts] //// //// [0.ts] - { type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols index 94599418c5d7b..3f49ebf17f7a1 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 3, 7)) ->Data : Symbol(Data, Decl(0.ts, 1, 1)) +>obj : Symbol(obj, Decl(0.ts, 2, 7)) +>Data : Symbol(Data, Decl(0.ts, 0, 1)) } export { } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias6.types b/tests/baselines/reference/declarationEmitInferedTypeAlias6.types index 922eb9ccf4422..7ea5f6ff2282c 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias6.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - { type Data = string | boolean; >Data : string | boolean diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias7.js b/tests/baselines/reference/declarationEmitInferedTypeAlias7.js index 9a9b1247e24d3..187913b0fd81e 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias7.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationEmitInferedTypeAlias7.ts] //// //// [0.ts] - export type Data = string | boolean; let obj: Data = true; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols index 8923fd72692f0..90a0e6f975a5a 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/0.ts === - export type Data = string | boolean; >Data : Symbol(Data, Decl(0.ts, 0, 0)) let obj: Data = true; ->obj : Symbol(obj, Decl(0.ts, 2, 3)) +>obj : Symbol(obj, Decl(0.ts, 1, 3)) >Data : Symbol(Data, Decl(0.ts, 0, 0)) === tests/cases/compiler/1.ts === diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias7.types b/tests/baselines/reference/declarationEmitInferedTypeAlias7.types index f4bcaaf5105bd..72289ce63dd98 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias7.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.ts === - export type Data = string | boolean; >Data : Data diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias8.js b/tests/baselines/reference/declarationEmitInferedTypeAlias8.js index 54a8ba37af1bd..d6e3c6bb7c211 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias8.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias8.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedTypeAlias8.ts] - type Foo = T | { x: Foo }; var x: Foo; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols index 9a0c0974e7994..3e4b21c4a061e 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias8.ts === - type Foo = T | { x: Foo }; >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9)) ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 19)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 0, 9)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 0, 9)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 0, 19)) >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 0, 9)) var x: Foo; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 2, 3)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 3)) >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0)) function returnSomeGlobalValue() { ->returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias8.ts, 2, 21)) +>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias8.ts, 1, 21)) return x; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 2, 3)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 3)) } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias8.types b/tests/baselines/reference/declarationEmitInferedTypeAlias8.types index 9fc0aaf701644..c58624aad5611 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias8.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias8.ts === - type Foo = T | { x: Foo }; >Foo : Foo >T : T diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias9.js b/tests/baselines/reference/declarationEmitInferedTypeAlias9.js index cddb463074098..3f237f2dc44c9 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias9.js +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias9.js @@ -1,5 +1,4 @@ //// [declarationEmitInferedTypeAlias9.ts] - type Foo = T | { x: Foo }; var x: Foo; diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols index 5057ef22c0b4d..3a147cd63a29f 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias9.ts === - type Foo = T | { x: Foo }; >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9)) ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 19)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 0, 9)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 0, 9)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 0, 19)) >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9)) +>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 0, 9)) var x: Foo; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 2, 3)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 3)) >Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0)) export function returnSomeGlobalValue() { ->returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias9.ts, 2, 21)) +>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias9.ts, 1, 21)) return x; ->x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 2, 3)) +>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 3)) } diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias9.types b/tests/baselines/reference/declarationEmitInferedTypeAlias9.types index d4f61bf927a51..b49c5c49887e5 100644 --- a/tests/baselines/reference/declarationEmitInferedTypeAlias9.types +++ b/tests/baselines/reference/declarationEmitInferedTypeAlias9.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitInferedTypeAlias9.ts === - type Foo = T | { x: Foo }; >Foo : T | { x: T | any; } >T : T diff --git a/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.errors.txt b/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.errors.txt index 7dc3a70fdc77d..fa504d6cb0a67 100644 --- a/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.errors.txt +++ b/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.ts(3,25): error TS2499: An interface can only extend an identifier/qualified-name with optional type arguments. +tests/cases/compiler/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.ts(2,25): error TS2499: An interface can only extend an identifier/qualified-name with optional type arguments. ==== tests/cases/compiler/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.ts (1 errors) ==== - class A { } interface Class extends (typeof A) { } ~~~~~~~~~~ diff --git a/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.js b/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.js index ef2d2e479b0db..fc50955c4e5cf 100644 --- a/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.js +++ b/tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.js @@ -1,5 +1,4 @@ //// [declarationEmitInterfaceWithNonEntityNameExpressionHeritage.ts] - class A { } interface Class extends (typeof A) { } diff --git a/tests/baselines/reference/declarationEmitInvalidExport.errors.txt b/tests/baselines/reference/declarationEmitInvalidExport.errors.txt index 529a6167973c0..74c8fc6b0a5e1 100644 --- a/tests/baselines/reference/declarationEmitInvalidExport.errors.txt +++ b/tests/baselines/reference/declarationEmitInvalidExport.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/declarationEmitInvalidExport.ts(3,3): error TS7027: Unreachable code detected. -tests/cases/compiler/declarationEmitInvalidExport.ts(5,30): error TS4081: Exported type alias 'MyClass' has or is using private name 'myClass'. -tests/cases/compiler/declarationEmitInvalidExport.ts(6,1): error TS1128: Declaration or statement expected. +tests/cases/compiler/declarationEmitInvalidExport.ts(2,3): error TS7027: Unreachable code detected. +tests/cases/compiler/declarationEmitInvalidExport.ts(4,30): error TS4081: Exported type alias 'MyClass' has or is using private name 'myClass'. +tests/cases/compiler/declarationEmitInvalidExport.ts(5,1): error TS1128: Declaration or statement expected. ==== tests/cases/compiler/declarationEmitInvalidExport.ts (3 errors) ==== - if (false) { export var myClass = 0; ~~~~~~ diff --git a/tests/baselines/reference/declarationEmitInvalidExport.js b/tests/baselines/reference/declarationEmitInvalidExport.js index d4280cd00c672..be71312b98eab 100644 --- a/tests/baselines/reference/declarationEmitInvalidExport.js +++ b/tests/baselines/reference/declarationEmitInvalidExport.js @@ -1,5 +1,4 @@ //// [declarationEmitInvalidExport.ts] - if (false) { export var myClass = 0; } diff --git a/tests/baselines/reference/declarationEmitPromise.js b/tests/baselines/reference/declarationEmitPromise.js index 7444a956a2add..6822dc56c3d6e 100644 --- a/tests/baselines/reference/declarationEmitPromise.js +++ b/tests/baselines/reference/declarationEmitPromise.js @@ -1,5 +1,4 @@ //// [declarationEmitPromise.ts] - export class bluebird { static all: Array>; } @@ -60,5 +59,5 @@ exports.runSampleBreaks = runSampleBreaks; export declare class bluebird { static all: Array>; } -export declare function runSampleWorks(a: bluebird, b?: bluebird, c?: bluebird, d?: bluebird, e?: bluebird): Promise<((f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T) & {}>; +export declare function runSampleWorks(a: bluebird, b?: bluebird, c?: bluebird, d?: bluebird, e?: bluebird): Promise<((f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T)>; export declare function runSampleBreaks(a: bluebird, b?: bluebird, c?: bluebird, d?: bluebird, e?: bluebird): Promise<((f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T)>; diff --git a/tests/baselines/reference/declarationEmitPromise.symbols b/tests/baselines/reference/declarationEmitPromise.symbols index 23d00ec6386c2..d1333bb060c78 100644 --- a/tests/baselines/reference/declarationEmitPromise.symbols +++ b/tests/baselines/reference/declarationEmitPromise.symbols @@ -1,155 +1,154 @@ === tests/cases/compiler/declarationEmitPromise.ts === - export class bluebird { >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 1, 22)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 0, 22)) static all: Array>; ->all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) } export async function runSampleWorks( ->runSampleWorks : Symbol(runSampleWorks, Decl(declarationEmitPromise.ts, 3, 1)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 5, 37)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 5, 39)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 5, 42)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 5, 45)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 5, 48)) +>runSampleWorks : Symbol(runSampleWorks, Decl(declarationEmitPromise.ts, 2, 1)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 4, 37)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 4, 39)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 4, 42)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 4, 45)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 4, 48)) a: bluebird, b?: bluebird, c?: bluebird, d?: bluebird, e?: bluebird) { ->a : Symbol(a, Decl(declarationEmitPromise.ts, 5, 52)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 4, 52)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 5, 37)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 6, 19)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 4, 37)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 5, 19)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 5, 39)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 6, 36)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 4, 39)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 5, 36)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 5, 42)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 6, 53)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 4, 42)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 5, 53)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 5, 45)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 6, 70)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 4, 45)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 5, 70)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 5, 48)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 4, 48)) let result = await (bluebird.all as any)([a, b, c, d, e].filter(el => !!el)); ->result : Symbol(result, Decl(declarationEmitPromise.ts, 7, 7)) ->bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>result : Symbol(result, Decl(declarationEmitPromise.ts, 6, 7)) +>bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(declarationEmitPromise.ts, 5, 52)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 6, 19)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 6, 36)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 6, 53)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 6, 70)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 4, 52)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 5, 19)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 5, 36)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 5, 53)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 5, 70)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->el : Symbol(el, Decl(declarationEmitPromise.ts, 7, 68)) ->el : Symbol(el, Decl(declarationEmitPromise.ts, 7, 68)) +>el : Symbol(el, Decl(declarationEmitPromise.ts, 6, 68)) +>el : Symbol(el, Decl(declarationEmitPromise.ts, 6, 68)) let func = (f: (a: A, b?: B, c?: C, d?: D, e?: E) => T): T => ->func : Symbol(func, Decl(declarationEmitPromise.ts, 8, 7)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 8, 16)) ->f : Symbol(f, Decl(declarationEmitPromise.ts, 8, 19)) ->a : Symbol(a, Decl(declarationEmitPromise.ts, 8, 23)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 5, 37)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 8, 28)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 5, 39)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 8, 35)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 5, 42)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 8, 42)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 5, 45)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 8, 49)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 5, 48)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 8, 16)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 8, 16)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 7, 7)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 7, 16)) +>f : Symbol(f, Decl(declarationEmitPromise.ts, 7, 19)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 7, 23)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 4, 37)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 7, 28)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 4, 39)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 7, 35)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 4, 42)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 7, 42)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 4, 45)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 7, 49)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 4, 48)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 7, 16)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 7, 16)) f.apply(this, result); >f.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(declarationEmitPromise.ts, 8, 19)) +>f : Symbol(f, Decl(declarationEmitPromise.ts, 7, 19)) >apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) ->result : Symbol(result, Decl(declarationEmitPromise.ts, 7, 7)) +>result : Symbol(result, Decl(declarationEmitPromise.ts, 6, 7)) let rfunc: typeof func & {} = func as any; // <- This is the only difference ->rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 10, 7)) ->func : Symbol(func, Decl(declarationEmitPromise.ts, 8, 7)) ->func : Symbol(func, Decl(declarationEmitPromise.ts, 8, 7)) +>rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 9, 7)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 7, 7)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 7, 7)) return rfunc ->rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 10, 7)) +>rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 9, 7)) } export async function runSampleBreaks( ->runSampleBreaks : Symbol(runSampleBreaks, Decl(declarationEmitPromise.ts, 12, 1)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 14, 38)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 14, 40)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 14, 43)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 14, 46)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 14, 49)) +>runSampleBreaks : Symbol(runSampleBreaks, Decl(declarationEmitPromise.ts, 11, 1)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 13, 38)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 13, 40)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 13, 43)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 13, 46)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 13, 49)) a: bluebird, b?: bluebird, c?: bluebird, d?: bluebird, e?: bluebird) { ->a : Symbol(a, Decl(declarationEmitPromise.ts, 14, 53)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 13, 53)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 14, 38)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 15, 19)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 13, 38)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 14, 19)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 14, 40)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 15, 36)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 13, 40)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 14, 36)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 14, 43)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 15, 53)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 13, 43)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 14, 53)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 14, 46)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 15, 70)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 13, 46)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 14, 70)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 14, 49)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 13, 49)) let result = await (bluebird.all as any)([a, b, c, d, e].filter(el => !!el)); ->result : Symbol(result, Decl(declarationEmitPromise.ts, 16, 7)) ->bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>result : Symbol(result, Decl(declarationEmitPromise.ts, 15, 7)) +>bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0)) ->all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 1, 26)) +>all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26)) >[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(declarationEmitPromise.ts, 14, 53)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 15, 19)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 15, 36)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 15, 53)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 15, 70)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 13, 53)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 14, 19)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 14, 36)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 14, 53)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 14, 70)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->el : Symbol(el, Decl(declarationEmitPromise.ts, 16, 68)) ->el : Symbol(el, Decl(declarationEmitPromise.ts, 16, 68)) +>el : Symbol(el, Decl(declarationEmitPromise.ts, 15, 68)) +>el : Symbol(el, Decl(declarationEmitPromise.ts, 15, 68)) let func = (f: (a: A, b?: B, c?: C, d?: D, e?: E) => T): T => ->func : Symbol(func, Decl(declarationEmitPromise.ts, 17, 7)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 17, 16)) ->f : Symbol(f, Decl(declarationEmitPromise.ts, 17, 19)) ->a : Symbol(a, Decl(declarationEmitPromise.ts, 17, 23)) ->A : Symbol(A, Decl(declarationEmitPromise.ts, 14, 38)) ->b : Symbol(b, Decl(declarationEmitPromise.ts, 17, 28)) ->B : Symbol(B, Decl(declarationEmitPromise.ts, 14, 40)) ->c : Symbol(c, Decl(declarationEmitPromise.ts, 17, 35)) ->C : Symbol(C, Decl(declarationEmitPromise.ts, 14, 43)) ->d : Symbol(d, Decl(declarationEmitPromise.ts, 17, 42)) ->D : Symbol(D, Decl(declarationEmitPromise.ts, 14, 46)) ->e : Symbol(e, Decl(declarationEmitPromise.ts, 17, 49)) ->E : Symbol(E, Decl(declarationEmitPromise.ts, 14, 49)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 17, 16)) ->T : Symbol(T, Decl(declarationEmitPromise.ts, 17, 16)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 16, 7)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 16, 16)) +>f : Symbol(f, Decl(declarationEmitPromise.ts, 16, 19)) +>a : Symbol(a, Decl(declarationEmitPromise.ts, 16, 23)) +>A : Symbol(A, Decl(declarationEmitPromise.ts, 13, 38)) +>b : Symbol(b, Decl(declarationEmitPromise.ts, 16, 28)) +>B : Symbol(B, Decl(declarationEmitPromise.ts, 13, 40)) +>c : Symbol(c, Decl(declarationEmitPromise.ts, 16, 35)) +>C : Symbol(C, Decl(declarationEmitPromise.ts, 13, 43)) +>d : Symbol(d, Decl(declarationEmitPromise.ts, 16, 42)) +>D : Symbol(D, Decl(declarationEmitPromise.ts, 13, 46)) +>e : Symbol(e, Decl(declarationEmitPromise.ts, 16, 49)) +>E : Symbol(E, Decl(declarationEmitPromise.ts, 13, 49)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 16, 16)) +>T : Symbol(T, Decl(declarationEmitPromise.ts, 16, 16)) f.apply(this, result); >f.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(declarationEmitPromise.ts, 17, 19)) +>f : Symbol(f, Decl(declarationEmitPromise.ts, 16, 19)) >apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) ->result : Symbol(result, Decl(declarationEmitPromise.ts, 16, 7)) +>result : Symbol(result, Decl(declarationEmitPromise.ts, 15, 7)) let rfunc: typeof func = func as any; // <- This is the only difference ->rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 19, 7)) ->func : Symbol(func, Decl(declarationEmitPromise.ts, 17, 7)) ->func : Symbol(func, Decl(declarationEmitPromise.ts, 17, 7)) +>rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 18, 7)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 16, 7)) +>func : Symbol(func, Decl(declarationEmitPromise.ts, 16, 7)) return rfunc ->rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 19, 7)) +>rfunc : Symbol(rfunc, Decl(declarationEmitPromise.ts, 18, 7)) } diff --git a/tests/baselines/reference/declarationEmitPromise.types b/tests/baselines/reference/declarationEmitPromise.types index 3cdf63ef478f2..70012094bf3dc 100644 --- a/tests/baselines/reference/declarationEmitPromise.types +++ b/tests/baselines/reference/declarationEmitPromise.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitPromise.ts === - export class bluebird { >bluebird : bluebird >T : T @@ -11,7 +10,7 @@ export class bluebird { } export async function runSampleWorks( ->runSampleWorks : (a: bluebird, b?: bluebird, c?: bluebird, d?: bluebird, e?: bluebird) => Promise<((f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T) & {}> +>runSampleWorks : (a: bluebird, b?: bluebird, c?: bluebird, d?: bluebird, e?: bluebird) => Promise<((f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T)> >A : A >B : B >C : C @@ -86,13 +85,13 @@ export async function runSampleWorks( >result : any let rfunc: typeof func & {} = func as any; // <- This is the only difference ->rfunc : ((f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T) & {} +>rfunc : (f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T >func : (f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T >func as any : any >func : (f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T return rfunc ->rfunc : ((f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T) & {} +>rfunc : (f: (a: A, b?: B, c?: C, d?: D, e?: E) => T) => T } export async function runSampleBreaks( diff --git a/tests/baselines/reference/declarationEmitProtectedMembers.js b/tests/baselines/reference/declarationEmitProtectedMembers.js index 7b3b42e7c97c4..a31d74fbbb1a5 100644 --- a/tests/baselines/reference/declarationEmitProtectedMembers.js +++ b/tests/baselines/reference/declarationEmitProtectedMembers.js @@ -1,5 +1,4 @@ //// [declarationEmitProtectedMembers.ts] - // Class with protected members class C1 { protected x: number; diff --git a/tests/baselines/reference/declarationEmitProtectedMembers.symbols b/tests/baselines/reference/declarationEmitProtectedMembers.symbols index 31f1a9a67e41d..189e9a418fbd9 100644 --- a/tests/baselines/reference/declarationEmitProtectedMembers.symbols +++ b/tests/baselines/reference/declarationEmitProtectedMembers.symbols @@ -1,114 +1,113 @@ === tests/cases/compiler/declarationEmitProtectedMembers.ts === - // Class with protected members class C1 { >C1 : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) protected x: number; ->x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) +>x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) protected f() { ->f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 3, 24)) +>f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 2, 24)) return this.x; ->this.x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) +>this.x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) >this : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) ->x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) +>x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) } protected set accessor(a: number) { } ->accessor : Symbol(C1.accessor, Decl(declarationEmitProtectedMembers.ts, 7, 5), Decl(declarationEmitProtectedMembers.ts, 9, 41)) ->a : Symbol(a, Decl(declarationEmitProtectedMembers.ts, 9, 27)) +>accessor : Symbol(C1.accessor, Decl(declarationEmitProtectedMembers.ts, 6, 5), Decl(declarationEmitProtectedMembers.ts, 8, 41)) +>a : Symbol(a, Decl(declarationEmitProtectedMembers.ts, 8, 27)) protected get accessor() { return 0; } ->accessor : Symbol(C1.accessor, Decl(declarationEmitProtectedMembers.ts, 7, 5), Decl(declarationEmitProtectedMembers.ts, 9, 41)) +>accessor : Symbol(C1.accessor, Decl(declarationEmitProtectedMembers.ts, 6, 5), Decl(declarationEmitProtectedMembers.ts, 8, 41)) protected static sx: number; ->sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) +>sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) protected static sf() { ->sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 12, 32)) +>sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 11, 32)) return this.sx; ->this.sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) +>this.sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) >this : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) ->sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) +>sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) } protected static set staticSetter(a: number) { } ->staticSetter : Symbol(C1.staticSetter, Decl(declarationEmitProtectedMembers.ts, 16, 5)) ->a : Symbol(a, Decl(declarationEmitProtectedMembers.ts, 18, 38)) +>staticSetter : Symbol(C1.staticSetter, Decl(declarationEmitProtectedMembers.ts, 15, 5)) +>a : Symbol(a, Decl(declarationEmitProtectedMembers.ts, 17, 38)) protected static get staticGetter() { return 0; } ->staticGetter : Symbol(C1.staticGetter, Decl(declarationEmitProtectedMembers.ts, 18, 52)) +>staticGetter : Symbol(C1.staticGetter, Decl(declarationEmitProtectedMembers.ts, 17, 52)) } // Derived class overriding protected members class C2 extends C1 { ->C2 : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) +>C2 : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) >C1 : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) protected f() { ->f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 23, 21)) +>f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 22, 21)) return super.f() + this.x; ->super.f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 3, 24)) +>super.f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 2, 24)) >super : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) ->f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 3, 24)) ->this.x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) ->this : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) ->x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 2, 10)) +>f : Symbol(C1.f, Decl(declarationEmitProtectedMembers.ts, 2, 24)) +>this.x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) +>this : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) +>x : Symbol(C1.x, Decl(declarationEmitProtectedMembers.ts, 1, 10)) } protected static sf() { ->sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 26, 5)) +>sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 25, 5)) return super.sf() + this.sx; ->super.sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 12, 32)) +>super.sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 11, 32)) >super : Symbol(C1, Decl(declarationEmitProtectedMembers.ts, 0, 0)) ->sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 12, 32)) ->this.sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) ->this : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) ->sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 10, 42)) +>sf : Symbol(C1.sf, Decl(declarationEmitProtectedMembers.ts, 11, 32)) +>this.sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) +>this : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) +>sx : Symbol(C1.sx, Decl(declarationEmitProtectedMembers.ts, 9, 42)) } } // Derived class making protected members public class C3 extends C2 { ->C3 : Symbol(C3, Decl(declarationEmitProtectedMembers.ts, 30, 1)) ->C2 : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) +>C3 : Symbol(C3, Decl(declarationEmitProtectedMembers.ts, 29, 1)) +>C2 : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) x: number; ->x : Symbol(C3.x, Decl(declarationEmitProtectedMembers.ts, 33, 21)) +>x : Symbol(C3.x, Decl(declarationEmitProtectedMembers.ts, 32, 21)) static sx: number; ->sx : Symbol(C3.sx, Decl(declarationEmitProtectedMembers.ts, 34, 14)) +>sx : Symbol(C3.sx, Decl(declarationEmitProtectedMembers.ts, 33, 14)) f() { ->f : Symbol(C3.f, Decl(declarationEmitProtectedMembers.ts, 35, 22)) +>f : Symbol(C3.f, Decl(declarationEmitProtectedMembers.ts, 34, 22)) return super.f(); ->super.f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 23, 21)) ->super : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) ->f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 23, 21)) +>super.f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 22, 21)) +>super : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) +>f : Symbol(C2.f, Decl(declarationEmitProtectedMembers.ts, 22, 21)) } static sf() { ->sf : Symbol(C3.sf, Decl(declarationEmitProtectedMembers.ts, 38, 5)) +>sf : Symbol(C3.sf, Decl(declarationEmitProtectedMembers.ts, 37, 5)) return super.sf(); ->super.sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 26, 5)) ->super : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 20, 1)) ->sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 26, 5)) +>super.sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 25, 5)) +>super : Symbol(C2, Decl(declarationEmitProtectedMembers.ts, 19, 1)) +>sf : Symbol(C2.sf, Decl(declarationEmitProtectedMembers.ts, 25, 5)) } static get staticGetter() { return 1; } ->staticGetter : Symbol(C3.staticGetter, Decl(declarationEmitProtectedMembers.ts, 41, 5)) +>staticGetter : Symbol(C3.staticGetter, Decl(declarationEmitProtectedMembers.ts, 40, 5)) } // Protected properties in constructors class C4 { ->C4 : Symbol(C4, Decl(declarationEmitProtectedMembers.ts, 44, 1)) +>C4 : Symbol(C4, Decl(declarationEmitProtectedMembers.ts, 43, 1)) constructor(protected a: number, protected b) { } ->a : Symbol(C4.a, Decl(declarationEmitProtectedMembers.ts, 48, 16)) ->b : Symbol(C4.b, Decl(declarationEmitProtectedMembers.ts, 48, 36)) +>a : Symbol(C4.a, Decl(declarationEmitProtectedMembers.ts, 47, 16)) +>b : Symbol(C4.b, Decl(declarationEmitProtectedMembers.ts, 47, 36)) } diff --git a/tests/baselines/reference/declarationEmitProtectedMembers.types b/tests/baselines/reference/declarationEmitProtectedMembers.types index b293487d57d46..ea3dfdae8bba7 100644 --- a/tests/baselines/reference/declarationEmitProtectedMembers.types +++ b/tests/baselines/reference/declarationEmitProtectedMembers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitProtectedMembers.ts === - // Class with protected members class C1 { >C1 : C1 diff --git a/tests/baselines/reference/declarationEmitReadonly.js b/tests/baselines/reference/declarationEmitReadonly.js index fd90188940c4d..4a3a80523ba22 100644 --- a/tests/baselines/reference/declarationEmitReadonly.js +++ b/tests/baselines/reference/declarationEmitReadonly.js @@ -1,5 +1,4 @@ //// [declarationEmitReadonly.ts] - class C { constructor(readonly x: number) {} } diff --git a/tests/baselines/reference/declarationEmitReadonly.symbols b/tests/baselines/reference/declarationEmitReadonly.symbols index 2ef310cf7dfe5..04c9277e96f7c 100644 --- a/tests/baselines/reference/declarationEmitReadonly.symbols +++ b/tests/baselines/reference/declarationEmitReadonly.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/classes/constructorDeclarations/constructorParameters/declarationEmitReadonly.ts === - class C { >C : Symbol(C, Decl(declarationEmitReadonly.ts, 0, 0)) constructor(readonly x: number) {} ->x : Symbol(C.x, Decl(declarationEmitReadonly.ts, 2, 16)) +>x : Symbol(C.x, Decl(declarationEmitReadonly.ts, 1, 16)) } diff --git a/tests/baselines/reference/declarationEmitReadonly.types b/tests/baselines/reference/declarationEmitReadonly.types index e64256698cfbb..5d2a69325e11b 100644 --- a/tests/baselines/reference/declarationEmitReadonly.types +++ b/tests/baselines/reference/declarationEmitReadonly.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/constructorDeclarations/constructorParameters/declarationEmitReadonly.ts === - class C { >C : C diff --git a/tests/baselines/reference/declarationEmitThisPredicates01.js b/tests/baselines/reference/declarationEmitThisPredicates01.js index e95a7db05edd7..70ed3147a9e06 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates01.js +++ b/tests/baselines/reference/declarationEmitThisPredicates01.js @@ -1,5 +1,4 @@ //// [declarationEmitThisPredicates01.ts] - export class C { m(): this is D { return this instanceof D; diff --git a/tests/baselines/reference/declarationEmitThisPredicates01.symbols b/tests/baselines/reference/declarationEmitThisPredicates01.symbols index af5da751b8c9c..221caece23e2b 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates01.symbols +++ b/tests/baselines/reference/declarationEmitThisPredicates01.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates01.ts === - export class C { >C : Symbol(C, Decl(declarationEmitThisPredicates01.ts, 0, 0)) m(): this is D { ->m : Symbol(C.m, Decl(declarationEmitThisPredicates01.ts, 1, 16)) ->D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 5, 1)) +>m : Symbol(C.m, Decl(declarationEmitThisPredicates01.ts, 0, 16)) +>D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 4, 1)) return this instanceof D; >this : Symbol(C, Decl(declarationEmitThisPredicates01.ts, 0, 0)) ->D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 5, 1)) +>D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 4, 1)) } } export class D extends C { ->D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 5, 1)) +>D : Symbol(D, Decl(declarationEmitThisPredicates01.ts, 4, 1)) >C : Symbol(C, Decl(declarationEmitThisPredicates01.ts, 0, 0)) } diff --git a/tests/baselines/reference/declarationEmitThisPredicates01.types b/tests/baselines/reference/declarationEmitThisPredicates01.types index 9d801a40965ca..486bf64b2f5d6 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates01.types +++ b/tests/baselines/reference/declarationEmitThisPredicates01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates01.ts === - export class C { >C : C diff --git a/tests/baselines/reference/declarationEmitThisPredicates02.errors.txt b/tests/baselines/reference/declarationEmitThisPredicates02.errors.txt index e4f95d9880344..ebaf4b0262f66 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates02.errors.txt +++ b/tests/baselines/reference/declarationEmitThisPredicates02.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates02.ts(9,10): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates02.ts(8,10): error TS2526: A 'this' type is available only in a non-static member of a class or interface. ==== tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicates02.ts (1 errors) ==== - export interface Foo { a: string; b: number; diff --git a/tests/baselines/reference/declarationEmitThisPredicates02.js b/tests/baselines/reference/declarationEmitThisPredicates02.js index 46deae372ca3f..f763a1cba46be 100644 --- a/tests/baselines/reference/declarationEmitThisPredicates02.js +++ b/tests/baselines/reference/declarationEmitThisPredicates02.js @@ -1,5 +1,4 @@ //// [declarationEmitThisPredicates02.ts] - export interface Foo { a: string; b: number; diff --git a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.errors.txt b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.errors.txt index 67c76283f808b..ea59c8fa9e8aa 100644 --- a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.errors.txt +++ b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName01.ts(3,18): error TS4055: Return type of public method from exported class has or is using private name 'D'. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName01.ts(2,18): error TS4055: Return type of public method from exported class has or is using private name 'D'. ==== tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName01.ts (1 errors) ==== - export class C { m(): this is D { ~ diff --git a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.js b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.js index a0f611d2d29a3..e7c4c9998b914 100644 --- a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.js +++ b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.js @@ -1,5 +1,4 @@ //// [declarationEmitThisPredicatesWithPrivateName01.ts] - export class C { m(): this is D { return this instanceof D; diff --git a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.errors.txt b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.errors.txt index bd2f4700fa248..f80c2bd0d6fd0 100644 --- a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.errors.txt +++ b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts(8,14): error TS4025: Exported variable 'obj' has or is using private name 'Foo'. -tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts(9,10): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts(7,14): error TS4025: Exported variable 'obj' has or is using private name 'Foo'. +tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts(8,10): error TS2526: A 'this' type is available only in a non-static member of a class or interface. ==== tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredicatesWithPrivateName02.ts (2 errors) ==== - interface Foo { a: string; b: number; diff --git a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.js b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.js index fe1a95db5e3fb..86fb2e0560711 100644 --- a/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.js +++ b/tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.js @@ -1,5 +1,4 @@ //// [declarationEmitThisPredicatesWithPrivateName02.ts] - interface Foo { a: string; b: number; diff --git a/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.errors.txt b/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.errors.txt index af0bcad47fa32..4b32bba9bbd9a 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.errors.txt +++ b/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts(2,18): error TS2304: Cannot find name 'Unknown'. -tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts(2,18): error TS4083: Type parameter 'T' of exported type alias has or is using private name 'Unknown'. +tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts(1,18): error TS2304: Cannot find name 'Unknown'. +tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts(1,18): error TS4083: Type parameter 'T' of exported type alias has or is using private name 'Unknown'. ==== tests/cases/compiler/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts (2 errors) ==== - type A = {} ~~~~~~~ !!! error TS2304: Cannot find name 'Unknown'. diff --git a/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js b/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js index eedcc6eccb7cc..2cfb8b4f6b0c2 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js +++ b/tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.ts] - type A = {} //// [declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.js] diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.js index 84b55a9792fb2..d2110bea4fe9f 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters1.ts] - export type Bar = () => [X, Y]; export type Foo = Bar; export const y = (x: Foo) => 1 diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.symbols index fa63e711f9a4a..2499c403b9b3b 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters1.ts === - export type Bar = () => [X, Y]; >Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 0)) ->X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 16)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 18)) ->X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 16)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 18)) +>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 18)) +>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 18)) export type Foo = Bar; ->Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 37)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 2, 16)) +>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 37)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 16)) >Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 0)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 2, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 16)) export const y = (x: Foo) => 1 ->y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 3, 12)) ->x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 3, 18)) ->Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 1, 37)) +>y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 2, 12)) +>x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 2, 18)) +>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters1.ts, 0, 37)) diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.types index a8b0f146f8ea0..eda6398899409 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters1.ts === - export type Bar = () => [X, Y]; >Bar : Bar >X : X diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js index 1bb6beac9e1f5..5c76056ac622b 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters2.ts] - export type Bar = () => [X, Y, Z]; export type Baz = Bar; export type Baa = Baz; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols index cc13e9fd30b24..af4197f5e37a1 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts === - export type Bar = () => [X, Y, Z]; >Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 0)) ->X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18)) ->Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 21)) ->X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18)) ->Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 21)) +>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 18)) +>Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 21)) +>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 16)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 18)) +>Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 21)) export type Baz = Bar; ->Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 43)) ->M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16)) ->N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 18)) +>Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 43)) +>M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16)) +>N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18)) >Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 0)) ->M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16)) ->N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 18)) +>M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16)) +>N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18)) export type Baa = Baz; ->Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 42)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 16)) ->Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 43)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 16)) +>Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 42)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16)) +>Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 43)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16)) export const y = (x: Baa) => 1 ->y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 4, 12)) ->x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 4, 18)) ->Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 42)) +>y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 12)) +>x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 18)) +>Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 42)) diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types index 74becc4976558..fbf51858af86d 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts === - export type Bar = () => [X, Y, Z]; >Bar : Bar >X : X diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js index 9e2a366a685b4..0cb7e23c4c54f 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters3.ts] - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols index a18b1372cf14d..b524c052c958f 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts === - type Foo = { >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 9)) +>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 9)) foo(): Foo ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 15)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 8)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 15)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 8)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 8)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 8)) }; function bar() { ->bar : Symbol(bar, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 3, 2)) +>bar : Symbol(bar, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 2)) return {} as Foo; >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0)) diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types index 1b2ff140178c6..b57b3743f7430 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts === - type Foo = { >Foo : Foo >T : T diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js index 26908d915e062..c336502913675 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters4.ts] - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols index de73f544645c2..6a94160c663fc 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts === - type Foo = { >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 9)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 11)) +>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 9)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 11)) foo(): Foo ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 18)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 8)) ->J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 10)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 18)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 8)) +>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 10)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 8)) ->J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 10)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 8)) +>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 10)) }; type SubFoo = Foo; ->SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 2)) ->R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 12)) +>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 2)) +>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 12)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0)) ->R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 12)) +>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 12)) function foo() { ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 32)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 32)) return {} as SubFoo; ->SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 2)) +>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 2)) } diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types index c545ac6bb0505..7272e1189ac40 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts === - type Foo = { >Foo : Foo >T : T diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt index 7f683dcc7b7b5..9552adfc0af98 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts(5,25): error TS4081: Exported type alias 'SubFoo' has or is using private name 'Foo'. +tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts(4,25): error TS4081: Exported type alias 'SubFoo' has or is using private name 'Foo'. ==== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts (1 errors) ==== - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js index 28997a754965a..cee701c045588 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters5.ts] - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js index c8001446e3e8c..a8e7dc8ca189f 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js @@ -1,5 +1,4 @@ //// [declarationEmitTypeAliasWithTypeParameters6.ts] - type Foo = { foo(): Foo }; diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols index ec29989f0781e..47769eb8727d9 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts === - type Foo = { >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0)) ->T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 9)) ->Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 11)) +>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 9)) +>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 11)) foo(): Foo ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 18)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 8)) ->J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 10)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 18)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 8)) +>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 10)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0)) ->U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 8)) ->J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 10)) +>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 8)) +>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 10)) }; type SubFoo = Foo; ->SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 2)) ->R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 12)) ->S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 14)) +>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 2)) +>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 12)) +>S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 14)) >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0)) ->S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 14)) ->R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 12)) +>S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 14)) +>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 12)) function foo() { ->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 30)) +>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 30)) return {} as SubFoo; ->SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 2)) +>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 2)) } diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types index b02ccbc2be7bc..59b5984d20e78 100644 --- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types +++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts === - type Foo = { >Foo : Foo >T : T diff --git a/tests/baselines/reference/declarationEmitUnknownImport.errors.txt b/tests/baselines/reference/declarationEmitUnknownImport.errors.txt index a2bee225fe86e..13b124d2bfebc 100644 --- a/tests/baselines/reference/declarationEmitUnknownImport.errors.txt +++ b/tests/baselines/reference/declarationEmitUnknownImport.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/declarationEmitUnknownImport.ts(2,14): error TS2304: Cannot find name 'SomeNonExistingName'. -tests/cases/compiler/declarationEmitUnknownImport.ts(2,14): error TS2503: Cannot find namespace 'SomeNonExistingName'. -tests/cases/compiler/declarationEmitUnknownImport.ts(2,14): error TS4000: Import declaration 'Foo' is using private name 'SomeNonExistingName'. +tests/cases/compiler/declarationEmitUnknownImport.ts(1,14): error TS2304: Cannot find name 'SomeNonExistingName'. +tests/cases/compiler/declarationEmitUnknownImport.ts(1,14): error TS2503: Cannot find namespace 'SomeNonExistingName'. +tests/cases/compiler/declarationEmitUnknownImport.ts(1,14): error TS4000: Import declaration 'Foo' is using private name 'SomeNonExistingName'. ==== tests/cases/compiler/declarationEmitUnknownImport.ts (3 errors) ==== - import Foo = SomeNonExistingName ~~~~~~~~~~~~~~~~~~~ !!! error TS2304: Cannot find name 'SomeNonExistingName'. diff --git a/tests/baselines/reference/declarationEmitUnknownImport.js b/tests/baselines/reference/declarationEmitUnknownImport.js index 1ac1e934578e5..6755c1e2b2b49 100644 --- a/tests/baselines/reference/declarationEmitUnknownImport.js +++ b/tests/baselines/reference/declarationEmitUnknownImport.js @@ -1,5 +1,4 @@ //// [declarationEmitUnknownImport.ts] - import Foo = SomeNonExistingName export {Foo} diff --git a/tests/baselines/reference/declarationEmitUnknownImport2.errors.txt b/tests/baselines/reference/declarationEmitUnknownImport2.errors.txt index db017d3c89aec..7149485972820 100644 --- a/tests/baselines/reference/declarationEmitUnknownImport2.errors.txt +++ b/tests/baselines/reference/declarationEmitUnknownImport2.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,12): error TS1005: '=' expected. -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,12): error TS2304: Cannot find name 'From'. -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,12): error TS2503: Cannot find namespace 'From'. -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,12): error TS4000: Import declaration 'Foo' is using private name 'From'. -tests/cases/compiler/declarationEmitUnknownImport2.ts(2,17): error TS1005: ';' expected. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,12): error TS1005: '=' expected. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,12): error TS2304: Cannot find name 'From'. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,12): error TS2503: Cannot find namespace 'From'. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,12): error TS4000: Import declaration 'Foo' is using private name 'From'. +tests/cases/compiler/declarationEmitUnknownImport2.ts(1,17): error TS1005: ';' expected. ==== tests/cases/compiler/declarationEmitUnknownImport2.ts (5 errors) ==== - import Foo From './Foo'; // Syntax error ~~~~ !!! error TS1005: '=' expected. diff --git a/tests/baselines/reference/declarationEmitUnknownImport2.js b/tests/baselines/reference/declarationEmitUnknownImport2.js index 1f291312913c2..2d34c869fe618 100644 --- a/tests/baselines/reference/declarationEmitUnknownImport2.js +++ b/tests/baselines/reference/declarationEmitUnknownImport2.js @@ -1,5 +1,4 @@ //// [declarationEmitUnknownImport2.ts] - import Foo From './Foo'; // Syntax error export default Foo diff --git a/tests/baselines/reference/declarationFileOverwriteError.errors.txt b/tests/baselines/reference/declarationFileOverwriteError.errors.txt index 846f2387dc1ab..c25c56df92605 100644 --- a/tests/baselines/reference/declarationFileOverwriteError.errors.txt +++ b/tests/baselines/reference/declarationFileOverwriteError.errors.txt @@ -5,7 +5,6 @@ error TS5055: Cannot write file 'tests/cases/compiler/a.d.ts' because it would o !!! error TS5055: Cannot write file 'tests/cases/compiler/a.d.ts' because it would overwrite input file. !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. ==== tests/cases/compiler/a.d.ts (0 errors) ==== - declare class c { } diff --git a/tests/baselines/reference/declarationFileOverwriteError.js b/tests/baselines/reference/declarationFileOverwriteError.js index 7bc57cce7d175..533cca55b2262 100644 --- a/tests/baselines/reference/declarationFileOverwriteError.js +++ b/tests/baselines/reference/declarationFileOverwriteError.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationFileOverwriteError.ts] //// //// [a.d.ts] - declare class c { } diff --git a/tests/baselines/reference/declarationFileOverwriteErrorWithOut.errors.txt b/tests/baselines/reference/declarationFileOverwriteErrorWithOut.errors.txt index b3c9fd4780d9a..3e43a21f51dbc 100644 --- a/tests/baselines/reference/declarationFileOverwriteErrorWithOut.errors.txt +++ b/tests/baselines/reference/declarationFileOverwriteErrorWithOut.errors.txt @@ -5,7 +5,6 @@ error TS5055: Cannot write file 'tests/cases/compiler/out.d.ts' because it would !!! error TS5055: Cannot write file 'tests/cases/compiler/out.d.ts' because it would overwrite input file. !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. ==== tests/cases/compiler/out.d.ts (0 errors) ==== - declare class c { } diff --git a/tests/baselines/reference/declarationFileOverwriteErrorWithOut.js b/tests/baselines/reference/declarationFileOverwriteErrorWithOut.js index 372d07f5ba7fb..72a5239b9a70c 100644 --- a/tests/baselines/reference/declarationFileOverwriteErrorWithOut.js +++ b/tests/baselines/reference/declarationFileOverwriteErrorWithOut.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationFileOverwriteErrorWithOut.ts] //// //// [out.d.ts] - declare class c { } diff --git a/tests/baselines/reference/declarationFiles.errors.txt b/tests/baselines/reference/declarationFiles.errors.txt index bbd65b6d6589c..67a3e91bfb0e8 100644 --- a/tests/baselines/reference/declarationFiles.errors.txt +++ b/tests/baselines/reference/declarationFiles.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/types/thisType/declarationFiles.ts(5,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface. -tests/cases/conformance/types/thisType/declarationFiles.ts(31,5): error TS2527: The inferred type of 'x1' references an inaccessible 'this' type. A type annotation is necessary. -tests/cases/conformance/types/thisType/declarationFiles.ts(33,5): error TS2527: The inferred type of 'x3' references an inaccessible 'this' type. A type annotation is necessary. -tests/cases/conformance/types/thisType/declarationFiles.ts(35,5): error TS2527: The inferred type of 'f1' references an inaccessible 'this' type. A type annotation is necessary. -tests/cases/conformance/types/thisType/declarationFiles.ts(41,5): error TS2527: The inferred type of 'f3' references an inaccessible 'this' type. A type annotation is necessary. +tests/cases/conformance/types/thisType/declarationFiles.ts(4,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/declarationFiles.ts(30,5): error TS2527: The inferred type of 'x1' references an inaccessible 'this' type. A type annotation is necessary. +tests/cases/conformance/types/thisType/declarationFiles.ts(32,5): error TS2527: The inferred type of 'x3' references an inaccessible 'this' type. A type annotation is necessary. +tests/cases/conformance/types/thisType/declarationFiles.ts(34,5): error TS2527: The inferred type of 'f1' references an inaccessible 'this' type. A type annotation is necessary. +tests/cases/conformance/types/thisType/declarationFiles.ts(40,5): error TS2527: The inferred type of 'f3' references an inaccessible 'this' type. A type annotation is necessary. ==== tests/cases/conformance/types/thisType/declarationFiles.ts (5 errors) ==== - class C1 { x: this; f(x: this): this { return undefined; } diff --git a/tests/baselines/reference/declarationFiles.js b/tests/baselines/reference/declarationFiles.js index 56f44b2c7e4f0..7ee2f344ea1bc 100644 --- a/tests/baselines/reference/declarationFiles.js +++ b/tests/baselines/reference/declarationFiles.js @@ -1,5 +1,4 @@ //// [declarationFiles.ts] - class C1 { x: this; f(x: this): this { return undefined; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences1.js b/tests/baselines/reference/declarationFilesWithTypeReferences1.js index b4695f28f134f..757fa4a7a3781 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences1.js +++ b/tests/baselines/reference/declarationFilesWithTypeReferences1.js @@ -1,13 +1,11 @@ //// [tests/cases/compiler/declarationFilesWithTypeReferences1.ts] //// //// [index.d.ts] - interface Error { stack2: string; } //// [app.ts] - function foo(): Error { return undefined; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences1.symbols b/tests/baselines/reference/declarationFilesWithTypeReferences1.symbols index 3d3df3c162280..58f8534b49258 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences1.symbols +++ b/tests/baselines/reference/declarationFilesWithTypeReferences1.symbols @@ -1,14 +1,12 @@ === /node_modules/@types/node/index.d.ts === - interface Error { >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(index.d.ts, 0, 0)) stack2: string; ->stack2 : Symbol(Error.stack2, Decl(index.d.ts, 1, 17)) +>stack2 : Symbol(Error.stack2, Decl(index.d.ts, 0, 17)) } === /app.ts === - function foo(): Error { >foo : Symbol(foo, Decl(app.ts, 0, 0)) >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(index.d.ts, 0, 0)) diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences1.types b/tests/baselines/reference/declarationFilesWithTypeReferences1.types index 7837b7b3a6c0e..4f7d980afc677 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences1.types +++ b/tests/baselines/reference/declarationFilesWithTypeReferences1.types @@ -1,5 +1,4 @@ === /node_modules/@types/node/index.d.ts === - interface Error { >Error : Error @@ -8,7 +7,6 @@ interface Error { } === /app.ts === - function foo(): Error { >foo : () => Error >Error : Error diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences2.js b/tests/baselines/reference/declarationFilesWithTypeReferences2.js index b85dcc4510757..6852d90d594b6 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences2.js +++ b/tests/baselines/reference/declarationFilesWithTypeReferences2.js @@ -1,13 +1,11 @@ //// [tests/cases/compiler/declarationFilesWithTypeReferences2.ts] //// //// [index.d.ts] - interface Error2 { stack2: string; } //// [app.ts] - function foo(): Error2 { return undefined; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences2.symbols b/tests/baselines/reference/declarationFilesWithTypeReferences2.symbols index dc6d8a3a6de2b..2a64e8c42f89f 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences2.symbols +++ b/tests/baselines/reference/declarationFilesWithTypeReferences2.symbols @@ -1,14 +1,12 @@ === /node_modules/@types/node/index.d.ts === - interface Error2 { >Error2 : Symbol(Error2, Decl(index.d.ts, 0, 0)) stack2: string; ->stack2 : Symbol(Error2.stack2, Decl(index.d.ts, 1, 18)) +>stack2 : Symbol(Error2.stack2, Decl(index.d.ts, 0, 18)) } === /app.ts === - function foo(): Error2 { >foo : Symbol(foo, Decl(app.ts, 0, 0)) >Error2 : Symbol(Error2, Decl(index.d.ts, 0, 0)) diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences2.types b/tests/baselines/reference/declarationFilesWithTypeReferences2.types index c56f4ba6a67d2..3412d193fe115 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences2.types +++ b/tests/baselines/reference/declarationFilesWithTypeReferences2.types @@ -1,5 +1,4 @@ === /node_modules/@types/node/index.d.ts === - interface Error2 { >Error2 : Error2 @@ -8,7 +7,6 @@ interface Error2 { } === /app.ts === - function foo(): Error2 { >foo : () => Error2 >Error2 : Error2 diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences3.js b/tests/baselines/reference/declarationFilesWithTypeReferences3.js index 3a18859c61090..dafec09848f75 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences3.js +++ b/tests/baselines/reference/declarationFilesWithTypeReferences3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationFilesWithTypeReferences3.ts] //// //// [index.d.ts] - interface Error2 { stack2: string; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences3.symbols b/tests/baselines/reference/declarationFilesWithTypeReferences3.symbols index 78335f988e9b7..fab7e5bbc06c5 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences3.symbols +++ b/tests/baselines/reference/declarationFilesWithTypeReferences3.symbols @@ -1,10 +1,9 @@ === /a/node_modules/@types/node/index.d.ts === - interface Error2 { >Error2 : Symbol(Error2, Decl(index.d.ts, 0, 0)) stack2: string; ->stack2 : Symbol(Error2.stack2, Decl(index.d.ts, 1, 18)) +>stack2 : Symbol(Error2.stack2, Decl(index.d.ts, 0, 18)) } === /a/app.ts === diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences3.types b/tests/baselines/reference/declarationFilesWithTypeReferences3.types index 9ac0105890abc..98b9bc14df059 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences3.types +++ b/tests/baselines/reference/declarationFilesWithTypeReferences3.types @@ -1,5 +1,4 @@ === /a/node_modules/@types/node/index.d.ts === - interface Error2 { >Error2 : Error2 diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences4.js b/tests/baselines/reference/declarationFilesWithTypeReferences4.js index b45860be9bb82..1356c459c0955 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences4.js +++ b/tests/baselines/reference/declarationFilesWithTypeReferences4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationFilesWithTypeReferences4.ts] //// //// [index.d.ts] - interface Error { stack2: string; } diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences4.symbols b/tests/baselines/reference/declarationFilesWithTypeReferences4.symbols index 216bd2a6a1c7d..f05bd814fc7d3 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences4.symbols +++ b/tests/baselines/reference/declarationFilesWithTypeReferences4.symbols @@ -1,10 +1,9 @@ === /a/node_modules/@types/node/index.d.ts === - interface Error { >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(index.d.ts, 0, 0)) stack2: string; ->stack2 : Symbol(Error.stack2, Decl(index.d.ts, 1, 17)) +>stack2 : Symbol(Error.stack2, Decl(index.d.ts, 0, 17)) } === /a/app.ts === diff --git a/tests/baselines/reference/declarationFilesWithTypeReferences4.types b/tests/baselines/reference/declarationFilesWithTypeReferences4.types index 0ae603716b100..cce74d144eebc 100644 --- a/tests/baselines/reference/declarationFilesWithTypeReferences4.types +++ b/tests/baselines/reference/declarationFilesWithTypeReferences4.types @@ -1,5 +1,4 @@ === /a/node_modules/@types/node/index.d.ts === - interface Error { >Error : Error diff --git a/tests/baselines/reference/declarationMerging2.js b/tests/baselines/reference/declarationMerging2.js index 64a6cf2d84910..b360d9af3f770 100644 --- a/tests/baselines/reference/declarationMerging2.js +++ b/tests/baselines/reference/declarationMerging2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/declarationMerging2.ts] //// //// [a.ts] - export class A { protected _f: number; getF() { return this._f; } diff --git a/tests/baselines/reference/declarationMerging2.symbols b/tests/baselines/reference/declarationMerging2.symbols index 050b5414da55f..3a740300633f4 100644 --- a/tests/baselines/reference/declarationMerging2.symbols +++ b/tests/baselines/reference/declarationMerging2.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/a.ts === - export class A { >A : Symbol(A, Decl(a.ts, 0, 0), Decl(b.ts, 1, 22)) protected _f: number; ->_f : Symbol(A._f, Decl(a.ts, 1, 16)) +>_f : Symbol(A._f, Decl(a.ts, 0, 16)) getF() { return this._f; } ->getF : Symbol(A.getF, Decl(a.ts, 2, 25)) ->this._f : Symbol(A._f, Decl(a.ts, 1, 16)) +>getF : Symbol(A.getF, Decl(a.ts, 1, 25)) +>this._f : Symbol(A._f, Decl(a.ts, 0, 16)) >this : Symbol(A, Decl(a.ts, 0, 0), Decl(b.ts, 1, 22)) ->_f : Symbol(A._f, Decl(a.ts, 1, 16)) +>_f : Symbol(A._f, Decl(a.ts, 0, 16)) } === tests/cases/compiler/b.ts === diff --git a/tests/baselines/reference/declarationMerging2.types b/tests/baselines/reference/declarationMerging2.types index 79e2818cf52b0..3d30bf89904a0 100644 --- a/tests/baselines/reference/declarationMerging2.types +++ b/tests/baselines/reference/declarationMerging2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A { >A : A diff --git a/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt b/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt index a46dfb0d3394a..b02b93e17b082 100644 --- a/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt +++ b/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt @@ -1,15 +1,13 @@ +tests/cases/conformance/classes/classDeclarations/file1.ts(1,15): error TS2300: Duplicate identifier 'C1'. tests/cases/conformance/classes/classDeclarations/file1.ts(3,15): error TS2300: Duplicate identifier 'C1'. -tests/cases/conformance/classes/classDeclarations/file1.ts(5,15): error TS2300: Duplicate identifier 'C1'. -tests/cases/conformance/classes/classDeclarations/file1.ts(7,15): error TS2300: Duplicate identifier 'C2'. -tests/cases/conformance/classes/classDeclarations/file1.ts(9,11): error TS2300: Duplicate identifier 'C2'. -tests/cases/conformance/classes/classDeclarations/file1.ts(11,15): error TS2300: Duplicate identifier 'C2'. -tests/cases/conformance/classes/classDeclarations/file2.ts(2,15): error TS2300: Duplicate identifier 'C3'. -tests/cases/conformance/classes/classDeclarations/file3.ts(2,15): error TS2300: Duplicate identifier 'C3'. +tests/cases/conformance/classes/classDeclarations/file1.ts(5,15): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file1.ts(7,11): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file1.ts(9,15): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file2.ts(1,15): error TS2300: Duplicate identifier 'C3'. +tests/cases/conformance/classes/classDeclarations/file3.ts(1,15): error TS2300: Duplicate identifier 'C3'. ==== tests/cases/conformance/classes/classDeclarations/file1.ts (5 errors) ==== - - declare class C1 {} ~~ !!! error TS2300: Duplicate identifier 'C1'. @@ -31,13 +29,11 @@ tests/cases/conformance/classes/classDeclarations/file3.ts(2,15): error TS2300: !!! error TS2300: Duplicate identifier 'C2'. ==== tests/cases/conformance/classes/classDeclarations/file2.ts (1 errors) ==== - declare class C3 { } ~~ !!! error TS2300: Duplicate identifier 'C3'. ==== tests/cases/conformance/classes/classDeclarations/file3.ts (1 errors) ==== - declare class C3 { } ~~ !!! error TS2300: Duplicate identifier 'C3'. \ No newline at end of file diff --git a/tests/baselines/reference/declaredClassMergedwithSelf.js b/tests/baselines/reference/declaredClassMergedwithSelf.js index a38391d90dbc8..efbf93f59d65a 100644 --- a/tests/baselines/reference/declaredClassMergedwithSelf.js +++ b/tests/baselines/reference/declaredClassMergedwithSelf.js @@ -1,8 +1,6 @@ //// [tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts] //// //// [file1.ts] - - declare class C1 {} declare class C1 {} @@ -14,11 +12,9 @@ interface C2 {} declare class C2 {} //// [file2.ts] - declare class C3 { } //// [file3.ts] - declare class C3 { } //// [file1.js] diff --git a/tests/baselines/reference/decoratedClassExportsCommonJS2.js b/tests/baselines/reference/decoratedClassExportsCommonJS2.js index 978d8f1840291..b9ef278ac73a8 100644 --- a/tests/baselines/reference/decoratedClassExportsCommonJS2.js +++ b/tests/baselines/reference/decoratedClassExportsCommonJS2.js @@ -1,5 +1,4 @@ //// [a.ts] - declare function forwardRef(x: any): any; declare var Something: any; @Something({ v: () => Testing123 }) diff --git a/tests/baselines/reference/decoratedClassExportsCommonJS2.symbols b/tests/baselines/reference/decoratedClassExportsCommonJS2.symbols index 8f587c1bff14d..77b1f92079220 100644 --- a/tests/baselines/reference/decoratedClassExportsCommonJS2.symbols +++ b/tests/baselines/reference/decoratedClassExportsCommonJS2.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : Symbol(forwardRef, Decl(a.ts, 0, 0)) ->x : Symbol(x, Decl(a.ts, 1, 28)) +>x : Symbol(x, Decl(a.ts, 0, 28)) declare var Something: any; ->Something : Symbol(Something, Decl(a.ts, 2, 11)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) @Something({ v: () => Testing123 }) ->Something : Symbol(Something, Decl(a.ts, 2, 11)) ->v : Symbol(v, Decl(a.ts, 3, 12)) ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) +>v : Symbol(v, Decl(a.ts, 2, 12)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) export class Testing123 { } ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) diff --git a/tests/baselines/reference/decoratedClassExportsCommonJS2.types b/tests/baselines/reference/decoratedClassExportsCommonJS2.types index eba793247de56..4c8cdfe4287cc 100644 --- a/tests/baselines/reference/decoratedClassExportsCommonJS2.types +++ b/tests/baselines/reference/decoratedClassExportsCommonJS2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : (x: any) => any >x : any diff --git a/tests/baselines/reference/decoratedClassExportsSystem1.js b/tests/baselines/reference/decoratedClassExportsSystem1.js index 2f33feb28fb99..b32c2c9b4451a 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem1.js +++ b/tests/baselines/reference/decoratedClassExportsSystem1.js @@ -1,5 +1,4 @@ //// [a.ts] - declare function forwardRef(x: any): any; declare var Something: any; @Something({ v: () => Testing123 }) diff --git a/tests/baselines/reference/decoratedClassExportsSystem1.symbols b/tests/baselines/reference/decoratedClassExportsSystem1.symbols index 559f78624e315..f81efa4d4755b 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem1.symbols +++ b/tests/baselines/reference/decoratedClassExportsSystem1.symbols @@ -1,26 +1,25 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : Symbol(forwardRef, Decl(a.ts, 0, 0)) ->x : Symbol(x, Decl(a.ts, 1, 28)) +>x : Symbol(x, Decl(a.ts, 0, 28)) declare var Something: any; ->Something : Symbol(Something, Decl(a.ts, 2, 11)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) @Something({ v: () => Testing123 }) ->Something : Symbol(Something, Decl(a.ts, 2, 11)) ->v : Symbol(v, Decl(a.ts, 3, 12)) ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) +>v : Symbol(v, Decl(a.ts, 2, 12)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) export class Testing123 { ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) static prop0: string; ->prop0 : Symbol(Testing123.prop0, Decl(a.ts, 4, 25)) +>prop0 : Symbol(Testing123.prop0, Decl(a.ts, 3, 25)) static prop1 = Testing123.prop0; ->prop1 : Symbol(Testing123.prop1, Decl(a.ts, 5, 25)) ->Testing123.prop0 : Symbol(Testing123.prop0, Decl(a.ts, 4, 25)) ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) ->prop0 : Symbol(Testing123.prop0, Decl(a.ts, 4, 25)) +>prop1 : Symbol(Testing123.prop1, Decl(a.ts, 4, 25)) +>Testing123.prop0 : Symbol(Testing123.prop0, Decl(a.ts, 3, 25)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) +>prop0 : Symbol(Testing123.prop0, Decl(a.ts, 3, 25)) } diff --git a/tests/baselines/reference/decoratedClassExportsSystem1.types b/tests/baselines/reference/decoratedClassExportsSystem1.types index 1cc69e8b68091..6b6a248d1dd37 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem1.types +++ b/tests/baselines/reference/decoratedClassExportsSystem1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : (x: any) => any >x : any diff --git a/tests/baselines/reference/decoratedClassExportsSystem2.js b/tests/baselines/reference/decoratedClassExportsSystem2.js index 2c9c62cadb22f..99ddd29bc2c1e 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem2.js +++ b/tests/baselines/reference/decoratedClassExportsSystem2.js @@ -1,5 +1,4 @@ //// [a.ts] - declare function forwardRef(x: any): any; declare var Something: any; @Something({ v: () => Testing123 }) diff --git a/tests/baselines/reference/decoratedClassExportsSystem2.symbols b/tests/baselines/reference/decoratedClassExportsSystem2.symbols index 8f587c1bff14d..77b1f92079220 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem2.symbols +++ b/tests/baselines/reference/decoratedClassExportsSystem2.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : Symbol(forwardRef, Decl(a.ts, 0, 0)) ->x : Symbol(x, Decl(a.ts, 1, 28)) +>x : Symbol(x, Decl(a.ts, 0, 28)) declare var Something: any; ->Something : Symbol(Something, Decl(a.ts, 2, 11)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) @Something({ v: () => Testing123 }) ->Something : Symbol(Something, Decl(a.ts, 2, 11)) ->v : Symbol(v, Decl(a.ts, 3, 12)) ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Something : Symbol(Something, Decl(a.ts, 1, 11)) +>v : Symbol(v, Decl(a.ts, 2, 12)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) export class Testing123 { } ->Testing123 : Symbol(Testing123, Decl(a.ts, 2, 27)) +>Testing123 : Symbol(Testing123, Decl(a.ts, 1, 27)) diff --git a/tests/baselines/reference/decoratedClassExportsSystem2.types b/tests/baselines/reference/decoratedClassExportsSystem2.types index eba793247de56..4c8cdfe4287cc 100644 --- a/tests/baselines/reference/decoratedClassExportsSystem2.types +++ b/tests/baselines/reference/decoratedClassExportsSystem2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/a.ts === - declare function forwardRef(x: any): any; >forwardRef : (x: any) => any >x : any diff --git a/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt b/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt index cef2f90f7041a..f9dd5b63b57e5 100644 --- a/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt +++ b/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts(9,14): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'. +tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts(8,14): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'. ==== tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts (1 errors) ==== - // from #2971 function func(s: string): void { } diff --git a/tests/baselines/reference/decoratorChecksFunctionBodies.js b/tests/baselines/reference/decoratorChecksFunctionBodies.js index 68dbe6bd1ef0c..20a58980e44e7 100644 --- a/tests/baselines/reference/decoratorChecksFunctionBodies.js +++ b/tests/baselines/reference/decoratorChecksFunctionBodies.js @@ -1,5 +1,4 @@ //// [decoratorChecksFunctionBodies.ts] - // from #2971 function func(s: string): void { } diff --git a/tests/baselines/reference/decoratorInJsFile.errors.txt b/tests/baselines/reference/decoratorInJsFile.errors.txt index 93bd5143b7486..521c67d4e2381 100644 --- a/tests/baselines/reference/decoratorInJsFile.errors.txt +++ b/tests/baselines/reference/decoratorInJsFile.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.js(4,12): error TS8010: 'types' can only be used in a .ts file. +tests/cases/compiler/a.js(3,12): error TS8010: 'types' can only be used in a .ts file. ==== tests/cases/compiler/a.js (1 errors) ==== - @SomeDecorator class SomeClass { foo(x: number) { diff --git a/tests/baselines/reference/decoratorInJsFile1.errors.txt b/tests/baselines/reference/decoratorInJsFile1.errors.txt index f4422c0c2d9b8..d660b6b28df1f 100644 --- a/tests/baselines/reference/decoratorInJsFile1.errors.txt +++ b/tests/baselines/reference/decoratorInJsFile1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/a.js(3,7): error TS1219: Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option to remove this warning. -tests/cases/compiler/a.js(4,12): error TS8010: 'types' can only be used in a .ts file. +tests/cases/compiler/a.js(2,7): error TS1219: Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option to remove this warning. +tests/cases/compiler/a.js(3,12): error TS8010: 'types' can only be used in a .ts file. ==== tests/cases/compiler/a.js (2 errors) ==== - @SomeDecorator class SomeClass { ~~~~~~~~~ diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js index 22e4a448f1e0b..08184bb7e6cfe 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/decorators/class/decoratorInstantiateModulesInFunctionBodies.ts] //// //// [a.ts] - // from #3108 export var test = 'abc'; diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols index f7c96097cafda..15993fc6b5a61 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/decorators/class/a.ts === - // from #3108 export var test = 'abc'; ->test : Symbol(test, Decl(a.ts, 2, 10)) +>test : Symbol(test, Decl(a.ts, 1, 10)) === tests/cases/conformance/decorators/class/b.ts === import { test } from './a'; diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types index d768f3c6c7ab7..d93f3d119d2c4 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/a.ts === - // from #3108 export var test = 'abc'; >test : string diff --git a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js index 970447efae0b2..9647165b650bc 100644 --- a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js +++ b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js @@ -1,5 +1,4 @@ //// [decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts] - declare var decorator: any; class MyClass { diff --git a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.symbols b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.symbols index cf550fb26e13e..ed09206356e62 100644 --- a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.symbols +++ b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts === - declare var decorator: any; ->decorator : Symbol(decorator, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 1, 11)) +>decorator : Symbol(decorator, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 0, 11)) class MyClass { ->MyClass : Symbol(MyClass, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 1, 27)) +>MyClass : Symbol(MyClass, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 0, 27)) constructor(test: string, test2: number) { ->test : Symbol(test, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 4, 16)) ->test2 : Symbol(test2, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 4, 29)) +>test : Symbol(test, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 3, 16)) +>test2 : Symbol(test2, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 3, 29)) } @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 1, 11)) +>decorator : Symbol(decorator, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 0, 11)) doSomething() { ->doSomething : Symbol(MyClass.doSomething, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 6, 5)) +>doSomething : Symbol(MyClass.doSomething, Decl(decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts, 5, 5)) } } diff --git a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.types b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.types index aebd8143eab23..2b372eebdf2b7 100644 --- a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.types +++ b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.ts === - declare var decorator: any; >decorator : any diff --git a/tests/baselines/reference/decoratorMetadataOnInferredType.js b/tests/baselines/reference/decoratorMetadataOnInferredType.js index 6f2476377293e..e7bd55ada6fdd 100644 --- a/tests/baselines/reference/decoratorMetadataOnInferredType.js +++ b/tests/baselines/reference/decoratorMetadataOnInferredType.js @@ -1,5 +1,4 @@ //// [decoratorMetadataOnInferredType.ts] - declare var console: { log(msg: string): void; }; diff --git a/tests/baselines/reference/decoratorMetadataOnInferredType.symbols b/tests/baselines/reference/decoratorMetadataOnInferredType.symbols index 5e0568a44a2eb..3230c270f2b3b 100644 --- a/tests/baselines/reference/decoratorMetadataOnInferredType.symbols +++ b/tests/baselines/reference/decoratorMetadataOnInferredType.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/decoratorMetadataOnInferredType.ts === - declare var console: { ->console : Symbol(console, Decl(decoratorMetadataOnInferredType.ts, 1, 11)) +>console : Symbol(console, Decl(decoratorMetadataOnInferredType.ts, 0, 11)) log(msg: string): void; ->log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 1, 22)) ->msg : Symbol(msg, Decl(decoratorMetadataOnInferredType.ts, 2, 8)) +>log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 0, 22)) +>msg : Symbol(msg, Decl(decoratorMetadataOnInferredType.ts, 1, 8)) }; class A { ->A : Symbol(A, Decl(decoratorMetadataOnInferredType.ts, 3, 2)) +>A : Symbol(A, Decl(decoratorMetadataOnInferredType.ts, 2, 2)) constructor() { console.log('new A'); } ->console.log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 1, 22)) ->console : Symbol(console, Decl(decoratorMetadataOnInferredType.ts, 1, 11)) ->log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 1, 22)) +>console.log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 0, 22)) +>console : Symbol(console, Decl(decoratorMetadataOnInferredType.ts, 0, 11)) +>log : Symbol(log, Decl(decoratorMetadataOnInferredType.ts, 0, 22)) } function decorator(target: Object, propertyKey: string) { ->decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 7, 1)) ->target : Symbol(target, Decl(decoratorMetadataOnInferredType.ts, 9, 19)) +>decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 6, 1)) +>target : Symbol(target, Decl(decoratorMetadataOnInferredType.ts, 8, 19)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->propertyKey : Symbol(propertyKey, Decl(decoratorMetadataOnInferredType.ts, 9, 34)) +>propertyKey : Symbol(propertyKey, Decl(decoratorMetadataOnInferredType.ts, 8, 34)) } export class B { ->B : Symbol(B, Decl(decoratorMetadataOnInferredType.ts, 10, 1)) +>B : Symbol(B, Decl(decoratorMetadataOnInferredType.ts, 9, 1)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 7, 1)) +>decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 6, 1)) x = new A(); ->x : Symbol(B.x, Decl(decoratorMetadataOnInferredType.ts, 12, 16)) ->A : Symbol(A, Decl(decoratorMetadataOnInferredType.ts, 3, 2)) +>x : Symbol(B.x, Decl(decoratorMetadataOnInferredType.ts, 11, 16)) +>A : Symbol(A, Decl(decoratorMetadataOnInferredType.ts, 2, 2)) } diff --git a/tests/baselines/reference/decoratorMetadataOnInferredType.types b/tests/baselines/reference/decoratorMetadataOnInferredType.types index 41ac7f060d2f2..a3ef51dfe26c6 100644 --- a/tests/baselines/reference/decoratorMetadataOnInferredType.types +++ b/tests/baselines/reference/decoratorMetadataOnInferredType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorMetadataOnInferredType.ts === - declare var console: { >console : { log(msg: string): void; } diff --git a/tests/baselines/reference/decoratorMetadataPromise.js b/tests/baselines/reference/decoratorMetadataPromise.js index 23491449dfa26..a370df936d58c 100644 --- a/tests/baselines/reference/decoratorMetadataPromise.js +++ b/tests/baselines/reference/decoratorMetadataPromise.js @@ -1,5 +1,4 @@ //// [decoratorMetadataPromise.ts] - declare const decorator: MethodDecorator; class A { diff --git a/tests/baselines/reference/decoratorMetadataPromise.symbols b/tests/baselines/reference/decoratorMetadataPromise.symbols index 6eec0fe46233e..ae929a4e34268 100644 --- a/tests/baselines/reference/decoratorMetadataPromise.symbols +++ b/tests/baselines/reference/decoratorMetadataPromise.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/decoratorMetadataPromise.ts === - declare const decorator: MethodDecorator; ->decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13)) +>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13)) >MethodDecorator : Symbol(MethodDecorator, Decl(lib.es5.d.ts, --, --)) class A { ->A : Symbol(A, Decl(decoratorMetadataPromise.ts, 1, 41)) +>A : Symbol(A, Decl(decoratorMetadataPromise.ts, 0, 41)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13)) +>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13)) async foo() {} ->foo : Symbol(A.foo, Decl(decoratorMetadataPromise.ts, 3, 9)) +>foo : Symbol(A.foo, Decl(decoratorMetadataPromise.ts, 2, 9)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13)) +>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13)) async bar(): Promise { return 0; } ->bar : Symbol(A.bar, Decl(decoratorMetadataPromise.ts, 5, 18)) +>bar : Symbol(A.bar, Decl(decoratorMetadataPromise.ts, 4, 18)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13)) +>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13)) baz(n: Promise): Promise { return n; } ->baz : Symbol(A.baz, Decl(decoratorMetadataPromise.ts, 7, 46)) ->n : Symbol(n, Decl(decoratorMetadataPromise.ts, 9, 8)) +>baz : Symbol(A.baz, Decl(decoratorMetadataPromise.ts, 6, 46)) +>n : Symbol(n, Decl(decoratorMetadataPromise.ts, 8, 8)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) ->n : Symbol(n, Decl(decoratorMetadataPromise.ts, 9, 8)) +>n : Symbol(n, Decl(decoratorMetadataPromise.ts, 8, 8)) } diff --git a/tests/baselines/reference/decoratorMetadataPromise.types b/tests/baselines/reference/decoratorMetadataPromise.types index eff5fe92c1273..1740f78c601c8 100644 --- a/tests/baselines/reference/decoratorMetadataPromise.types +++ b/tests/baselines/reference/decoratorMetadataPromise.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorMetadataPromise.ts === - declare const decorator: MethodDecorator; >decorator : MethodDecorator >MethodDecorator : MethodDecorator diff --git a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.js b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.js index a65ba5b2f7388..404bc9a1d597e 100644 --- a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.js +++ b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/decoratorMetadataRestParameterWithImportedType.ts] //// //// [aux.ts] - export class SomeClass { field: string; } diff --git a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.symbols b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.symbols index 9bd293cdfcb10..8b8fdf243f8e2 100644 --- a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.symbols +++ b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/aux.ts === - export class SomeClass { >SomeClass : Symbol(SomeClass, Decl(aux.ts, 0, 0)) field: string; ->field : Symbol(SomeClass.field, Decl(aux.ts, 1, 24)) +>field : Symbol(SomeClass.field, Decl(aux.ts, 0, 24)) } === tests/cases/compiler/aux1.ts === diff --git a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.types b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.types index 6c27aa2c94210..60db876576d22 100644 --- a/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.types +++ b/tests/baselines/reference/decoratorMetadataRestParameterWithImportedType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/aux.ts === - export class SomeClass { >SomeClass : SomeClass diff --git a/tests/baselines/reference/decoratorMetadataWithConstructorType.js b/tests/baselines/reference/decoratorMetadataWithConstructorType.js index 10aa42ddce7da..95c1917834598 100644 --- a/tests/baselines/reference/decoratorMetadataWithConstructorType.js +++ b/tests/baselines/reference/decoratorMetadataWithConstructorType.js @@ -1,5 +1,4 @@ //// [decoratorMetadataWithConstructorType.ts] - declare var console: { log(msg: string): void; }; diff --git a/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols b/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols index 5ee6edd1aee3a..cfe4fc002d697 100644 --- a/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols +++ b/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols @@ -1,39 +1,38 @@ === tests/cases/compiler/decoratorMetadataWithConstructorType.ts === - declare var console: { ->console : Symbol(console, Decl(decoratorMetadataWithConstructorType.ts, 1, 11)) +>console : Symbol(console, Decl(decoratorMetadataWithConstructorType.ts, 0, 11)) log(msg: string): void; ->log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 1, 22)) ->msg : Symbol(msg, Decl(decoratorMetadataWithConstructorType.ts, 2, 8)) +>log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 0, 22)) +>msg : Symbol(msg, Decl(decoratorMetadataWithConstructorType.ts, 1, 8)) }; class A { ->A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 3, 2)) +>A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 2, 2)) constructor() { console.log('new A'); } ->console.log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 1, 22)) ->console : Symbol(console, Decl(decoratorMetadataWithConstructorType.ts, 1, 11)) ->log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 1, 22)) +>console.log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 0, 22)) +>console : Symbol(console, Decl(decoratorMetadataWithConstructorType.ts, 0, 11)) +>log : Symbol(log, Decl(decoratorMetadataWithConstructorType.ts, 0, 22)) } function decorator(target: Object, propertyKey: string) { ->decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 7, 1)) ->target : Symbol(target, Decl(decoratorMetadataWithConstructorType.ts, 9, 19)) +>decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 6, 1)) +>target : Symbol(target, Decl(decoratorMetadataWithConstructorType.ts, 8, 19)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->propertyKey : Symbol(propertyKey, Decl(decoratorMetadataWithConstructorType.ts, 9, 34)) +>propertyKey : Symbol(propertyKey, Decl(decoratorMetadataWithConstructorType.ts, 8, 34)) } export class B { ->B : Symbol(B, Decl(decoratorMetadataWithConstructorType.ts, 10, 1)) +>B : Symbol(B, Decl(decoratorMetadataWithConstructorType.ts, 9, 1)) @decorator ->decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 7, 1)) +>decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 6, 1)) x: A = new A(); ->x : Symbol(B.x, Decl(decoratorMetadataWithConstructorType.ts, 12, 16)) ->A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 3, 2)) ->A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 3, 2)) +>x : Symbol(B.x, Decl(decoratorMetadataWithConstructorType.ts, 11, 16)) +>A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 2, 2)) +>A : Symbol(A, Decl(decoratorMetadataWithConstructorType.ts, 2, 2)) } diff --git a/tests/baselines/reference/decoratorMetadataWithConstructorType.types b/tests/baselines/reference/decoratorMetadataWithConstructorType.types index 4ca404c81166a..262e31c38459c 100644 --- a/tests/baselines/reference/decoratorMetadataWithConstructorType.types +++ b/tests/baselines/reference/decoratorMetadataWithConstructorType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorMetadataWithConstructorType.ts === - declare var console: { >console : { log(msg: string): void; } diff --git a/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt b/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt index c4585b8301fea..603c449aeb466 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt +++ b/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt @@ -3,7 +3,6 @@ tests/cases/conformance/decorators/class/constructor/2.ts(2,19): error TS2691: A ==== tests/cases/conformance/decorators/class/constructor/0.ts (0 errors) ==== - export class base { } export function foo(target: Object, propertyKey: string | symbol, parameterIndex: number) { } diff --git a/tests/baselines/reference/decoratorOnClassConstructor2.js b/tests/baselines/reference/decoratorOnClassConstructor2.js index 2af3b0426dc02..999ffbc5e60e8 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor2.js +++ b/tests/baselines/reference/decoratorOnClassConstructor2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/decorators/class/constructor/decoratorOnClassConstructor2.ts] //// //// [0.ts] - export class base { } export function foo(target: Object, propertyKey: string | symbol, parameterIndex: number) { } diff --git a/tests/baselines/reference/decoratorOnClassConstructor3.js b/tests/baselines/reference/decoratorOnClassConstructor3.js index 4ed401284a9f5..98edaebe920b8 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor3.js +++ b/tests/baselines/reference/decoratorOnClassConstructor3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/decorators/class/constructor/decoratorOnClassConstructor3.ts] //// //// [0.ts] - export class base { } export function foo(target: Object, propertyKey: string | symbol, parameterIndex: number) { } diff --git a/tests/baselines/reference/decoratorOnClassConstructor3.symbols b/tests/baselines/reference/decoratorOnClassConstructor3.symbols index 12c20c9a8cca4..3db6bf0f936fa 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor3.symbols +++ b/tests/baselines/reference/decoratorOnClassConstructor3.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/decorators/class/constructor/0.ts === - export class base { } >base : Symbol(base, Decl(0.ts, 0, 0)) export function foo(target: Object, propertyKey: string | symbol, parameterIndex: number) { } ->foo : Symbol(foo, Decl(0.ts, 1, 21)) ->target : Symbol(target, Decl(0.ts, 2, 20)) +>foo : Symbol(foo, Decl(0.ts, 0, 21)) +>target : Symbol(target, Decl(0.ts, 1, 20)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->propertyKey : Symbol(propertyKey, Decl(0.ts, 2, 35)) ->parameterIndex : Symbol(parameterIndex, Decl(0.ts, 2, 65)) +>propertyKey : Symbol(propertyKey, Decl(0.ts, 1, 35)) +>parameterIndex : Symbol(parameterIndex, Decl(0.ts, 1, 65)) === tests/cases/conformance/decorators/class/constructor/2.ts === import {base} from "./0" diff --git a/tests/baselines/reference/decoratorOnClassConstructor3.types b/tests/baselines/reference/decoratorOnClassConstructor3.types index dc1e22c1688b4..49e16d09e7610 100644 --- a/tests/baselines/reference/decoratorOnClassConstructor3.types +++ b/tests/baselines/reference/decoratorOnClassConstructor3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/decorators/class/constructor/0.ts === - export class base { } >base : base diff --git a/tests/baselines/reference/decoratorWithUnderscoreMethod.js b/tests/baselines/reference/decoratorWithUnderscoreMethod.js index bf79890263bc7..9ac2a88aa5162 100644 --- a/tests/baselines/reference/decoratorWithUnderscoreMethod.js +++ b/tests/baselines/reference/decoratorWithUnderscoreMethod.js @@ -1,5 +1,4 @@ //// [decoratorWithUnderscoreMethod.ts] - declare var console : { log(arg: string): void }; function dec(): Function { return function (target: any, propKey: string, descr: PropertyDescriptor): void { diff --git a/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols b/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols index a512bde71f6fe..b9c7be21514be 100644 --- a/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols +++ b/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols @@ -1,26 +1,25 @@ === tests/cases/compiler/decoratorWithUnderscoreMethod.ts === - declare var console : { log(arg: string): void }; ->console : Symbol(console, Decl(decoratorWithUnderscoreMethod.ts, 1, 11)) ->log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 1, 23)) ->arg : Symbol(arg, Decl(decoratorWithUnderscoreMethod.ts, 1, 28)) +>console : Symbol(console, Decl(decoratorWithUnderscoreMethod.ts, 0, 11)) +>log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 0, 23)) +>arg : Symbol(arg, Decl(decoratorWithUnderscoreMethod.ts, 0, 28)) function dec(): Function { ->dec : Symbol(dec, Decl(decoratorWithUnderscoreMethod.ts, 1, 49)) +>dec : Symbol(dec, Decl(decoratorWithUnderscoreMethod.ts, 0, 49)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) return function (target: any, propKey: string, descr: PropertyDescriptor): void { ->target : Symbol(target, Decl(decoratorWithUnderscoreMethod.ts, 3, 21)) ->propKey : Symbol(propKey, Decl(decoratorWithUnderscoreMethod.ts, 3, 33)) ->descr : Symbol(descr, Decl(decoratorWithUnderscoreMethod.ts, 3, 50)) +>target : Symbol(target, Decl(decoratorWithUnderscoreMethod.ts, 2, 21)) +>propKey : Symbol(propKey, Decl(decoratorWithUnderscoreMethod.ts, 2, 33)) +>descr : Symbol(descr, Decl(decoratorWithUnderscoreMethod.ts, 2, 50)) >PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --)) console.log(target[propKey]); ->console.log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 1, 23)) ->console : Symbol(console, Decl(decoratorWithUnderscoreMethod.ts, 1, 11)) ->log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 1, 23)) ->target : Symbol(target, Decl(decoratorWithUnderscoreMethod.ts, 3, 21)) ->propKey : Symbol(propKey, Decl(decoratorWithUnderscoreMethod.ts, 3, 33)) +>console.log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 0, 23)) +>console : Symbol(console, Decl(decoratorWithUnderscoreMethod.ts, 0, 11)) +>log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 0, 23)) +>target : Symbol(target, Decl(decoratorWithUnderscoreMethod.ts, 2, 21)) +>propKey : Symbol(propKey, Decl(decoratorWithUnderscoreMethod.ts, 2, 33)) //logs undefined //propKey has three underscores as prefix, but the method has only two underscores @@ -28,14 +27,14 @@ function dec(): Function { } class A { ->A : Symbol(A, Decl(decoratorWithUnderscoreMethod.ts, 8, 1)) +>A : Symbol(A, Decl(decoratorWithUnderscoreMethod.ts, 7, 1)) @dec() ->dec : Symbol(dec, Decl(decoratorWithUnderscoreMethod.ts, 1, 49)) +>dec : Symbol(dec, Decl(decoratorWithUnderscoreMethod.ts, 0, 49)) private __foo(bar: string): void { ->__foo : Symbol(A.__foo, Decl(decoratorWithUnderscoreMethod.ts, 10, 9)) ->bar : Symbol(bar, Decl(decoratorWithUnderscoreMethod.ts, 12, 18)) +>__foo : Symbol(A.__foo, Decl(decoratorWithUnderscoreMethod.ts, 9, 9)) +>bar : Symbol(bar, Decl(decoratorWithUnderscoreMethod.ts, 11, 18)) // do something with bar } diff --git a/tests/baselines/reference/decoratorWithUnderscoreMethod.types b/tests/baselines/reference/decoratorWithUnderscoreMethod.types index 1ce08dc8a9eed..a75952d37aa61 100644 --- a/tests/baselines/reference/decoratorWithUnderscoreMethod.types +++ b/tests/baselines/reference/decoratorWithUnderscoreMethod.types @@ -1,5 +1,4 @@ === tests/cases/compiler/decoratorWithUnderscoreMethod.ts === - declare var console : { log(arg: string): void }; >console : { log(arg: string): void; } >log : (arg: string) => void diff --git a/tests/baselines/reference/defaultExportWithOverloads01.js b/tests/baselines/reference/defaultExportWithOverloads01.js index a273b8916792a..1b4030387509c 100644 --- a/tests/baselines/reference/defaultExportWithOverloads01.js +++ b/tests/baselines/reference/defaultExportWithOverloads01.js @@ -1,5 +1,4 @@ //// [defaultExportWithOverloads01.ts] - export default function f(); export default function f(x: string); export default function f(...args: any[]) { diff --git a/tests/baselines/reference/defaultExportWithOverloads01.symbols b/tests/baselines/reference/defaultExportWithOverloads01.symbols index a5ff0df5262d8..2438f8d838bf1 100644 --- a/tests/baselines/reference/defaultExportWithOverloads01.symbols +++ b/tests/baselines/reference/defaultExportWithOverloads01.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts === - export default function f(); ->f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37)) +>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 0, 28), Decl(defaultExportWithOverloads01.ts, 1, 37)) export default function f(x: string); ->f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37)) ->x : Symbol(x, Decl(defaultExportWithOverloads01.ts, 2, 26)) +>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 0, 28), Decl(defaultExportWithOverloads01.ts, 1, 37)) +>x : Symbol(x, Decl(defaultExportWithOverloads01.ts, 1, 26)) export default function f(...args: any[]) { ->f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37)) ->args : Symbol(args, Decl(defaultExportWithOverloads01.ts, 3, 26)) +>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 0, 28), Decl(defaultExportWithOverloads01.ts, 1, 37)) +>args : Symbol(args, Decl(defaultExportWithOverloads01.ts, 2, 26)) } diff --git a/tests/baselines/reference/defaultExportWithOverloads01.types b/tests/baselines/reference/defaultExportWithOverloads01.types index c006083b4bade..6b8883783f31a 100644 --- a/tests/baselines/reference/defaultExportWithOverloads01.types +++ b/tests/baselines/reference/defaultExportWithOverloads01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts === - export default function f(); >f : { (): any; (x: string): any; } diff --git a/tests/baselines/reference/defaultExportsCannotMerge01.errors.txt b/tests/baselines/reference/defaultExportsCannotMerge01.errors.txt index 15c60e32d9f80..5c28d8ee14135 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge01.errors.txt +++ b/tests/baselines/reference/defaultExportsCannotMerge01.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/modules/m1.ts(2,25): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. -tests/cases/conformance/es6/modules/m1.ts(11,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(1,25): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(10,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. tests/cases/conformance/es6/modules/m2.ts(1,20): error TS2307: Cannot find module 'm1'. ==== tests/cases/conformance/es6/modules/m1.ts (2 errors) ==== - export default function Decl() { ~~~~ !!! error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. diff --git a/tests/baselines/reference/defaultExportsCannotMerge01.js b/tests/baselines/reference/defaultExportsCannotMerge01.js index aaadfaefebbfd..c7091371d3612 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge01.js +++ b/tests/baselines/reference/defaultExportsCannotMerge01.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/defaultExportsCannotMerge01.ts] //// //// [m1.ts] - export default function Decl() { return 0; } diff --git a/tests/baselines/reference/defaultExportsCannotMerge02.errors.txt b/tests/baselines/reference/defaultExportsCannotMerge02.errors.txt index 30bab504c7e4e..737a481487b96 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge02.errors.txt +++ b/tests/baselines/reference/defaultExportsCannotMerge02.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. -tests/cases/conformance/es6/modules/m1.ts(5,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(1,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(4,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. tests/cases/conformance/es6/modules/m2.ts(1,20): error TS2307: Cannot find module 'm1'. ==== tests/cases/conformance/es6/modules/m1.ts (2 errors) ==== - export default class Decl { ~~~~ !!! error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. diff --git a/tests/baselines/reference/defaultExportsCannotMerge02.js b/tests/baselines/reference/defaultExportsCannotMerge02.js index b83d54548ca6b..19a2de450770e 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge02.js +++ b/tests/baselines/reference/defaultExportsCannotMerge02.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/defaultExportsCannotMerge02.ts] //// //// [m1.ts] - export default class Decl { } diff --git a/tests/baselines/reference/defaultExportsCannotMerge03.errors.txt b/tests/baselines/reference/defaultExportsCannotMerge03.errors.txt index e8782abedd6ff..7452554fd352b 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge03.errors.txt +++ b/tests/baselines/reference/defaultExportsCannotMerge03.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. -tests/cases/conformance/es6/modules/m1.ts(5,11): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(1,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. +tests/cases/conformance/es6/modules/m1.ts(4,11): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. tests/cases/conformance/es6/modules/m2.ts(1,20): error TS2307: Cannot find module 'm1'. ==== tests/cases/conformance/es6/modules/m1.ts (2 errors) ==== - export default class Decl { ~~~~ !!! error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead. diff --git a/tests/baselines/reference/defaultExportsCannotMerge03.js b/tests/baselines/reference/defaultExportsCannotMerge03.js index 254723ec5f1f5..1f8ac49f3c40e 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge03.js +++ b/tests/baselines/reference/defaultExportsCannotMerge03.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/defaultExportsCannotMerge03.ts] //// //// [m1.ts] - export default class Decl { } diff --git a/tests/baselines/reference/defaultExportsCannotMerge04.errors.txt b/tests/baselines/reference/defaultExportsCannotMerge04.errors.txt index 000a9b8f30e4e..91e07720c8991 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge04.errors.txt +++ b/tests/baselines/reference/defaultExportsCannotMerge04.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(2,25): error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. -tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(5,11): error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. -tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(9,11): error TS2395: Individual declarations in merged declaration 'Foo' must be all exported or all local. -tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(12,18): error TS2395: Individual declarations in merged declaration 'Foo' must be all exported or all local. +tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(1,25): error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. +tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(4,11): error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. +tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(8,11): error TS2395: Individual declarations in merged declaration 'Foo' must be all exported or all local. +tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts(11,18): error TS2395: Individual declarations in merged declaration 'Foo' must be all exported or all local. ==== tests/cases/conformance/es6/modules/defaultExportsCannotMerge04.ts (4 errors) ==== - export default function Foo() { ~~~ !!! error TS2652: Merged declaration 'Foo' cannot include a default export declaration. Consider adding a separate 'export default Foo' declaration instead. diff --git a/tests/baselines/reference/defaultExportsCannotMerge04.js b/tests/baselines/reference/defaultExportsCannotMerge04.js index 38ab4861c62b0..de32618d8cce7 100644 --- a/tests/baselines/reference/defaultExportsCannotMerge04.js +++ b/tests/baselines/reference/defaultExportsCannotMerge04.js @@ -1,5 +1,4 @@ //// [defaultExportsCannotMerge04.ts] - export default function Foo() { } diff --git a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.js b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.js index 7706181b343fa..35e8ec98a8eb8 100644 --- a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.js +++ b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.js @@ -1,5 +1,4 @@ //// [defaultOfAnyInStrictNullChecks.ts] - // Regression test for #8295 function foo() { diff --git a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.symbols b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.symbols index c7de7f6b2f3ab..d500d7c8bf612 100644 --- a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.symbols +++ b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/defaultOfAnyInStrictNullChecks.ts === - // Regression test for #8295 function foo() { @@ -8,11 +7,11 @@ function foo() { try { } catch (e) { ->e : Symbol(e, Decl(defaultOfAnyInStrictNullChecks.ts, 6, 11)) +>e : Symbol(e, Decl(defaultOfAnyInStrictNullChecks.ts, 5, 11)) let s = e.message; ->s : Symbol(s, Decl(defaultOfAnyInStrictNullChecks.ts, 7, 11)) ->e : Symbol(e, Decl(defaultOfAnyInStrictNullChecks.ts, 6, 11)) +>s : Symbol(s, Decl(defaultOfAnyInStrictNullChecks.ts, 6, 11)) +>e : Symbol(e, Decl(defaultOfAnyInStrictNullChecks.ts, 5, 11)) } } diff --git a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.types b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.types index 8e4c1adcd6185..bae0ac690f202 100644 --- a/tests/baselines/reference/defaultOfAnyInStrictNullChecks.types +++ b/tests/baselines/reference/defaultOfAnyInStrictNullChecks.types @@ -1,5 +1,4 @@ === tests/cases/compiler/defaultOfAnyInStrictNullChecks.ts === - // Regression test for #8295 function foo() { diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js index a1e9399c563f7..d41542e90c0f4 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js @@ -1,5 +1,4 @@ //// [derivedClassConstructorWithExplicitReturns01.ts] - class C { cProp = 10; diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js.map b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js.map index f2acf9427cf8b..4075fca49c9ed 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js.map +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.js.map @@ -1,2 +1,2 @@ //// [derivedClassConstructorWithExplicitReturns01.js.map] -{"version":3,"file":"derivedClassConstructorWithExplicitReturns01.js","sourceRoot":"","sources":["derivedClassConstructorWithExplicitReturns01.ts"],"names":[],"mappings":";;;;;;;;;;AACA;IAKI,WAAY,KAAa;QAJzB,UAAK,GAAG,EAAE,CAAC;QAKP,MAAM,CAAC;YACH,KAAK,EAAE,KAAK;YACZ,GAAG;gBACC,MAAM,CAAC,8BAA8B,CAAC;YAC1C,CAAC;SACJ,CAAA;IACL,CAAC;IATD,eAAG,GAAH,cAAQ,MAAM,CAAC,uBAAuB,CAAC,CAAC,CAAC;IAU7C,QAAC;AAAD,CAAC,AAbD,IAaC;AAED;IAAgB,qBAAC;IAGb,WAAY,CAAO;QAAP,kBAAA,EAAA,OAAO;QAAnB,YACI,kBAAM,CAAC,CAAC,SAYX;QAfD,WAAK,GAAG,cAAM,OAAA,KAAI,EAAJ,CAAI,CAAC;QAKf,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;YACtB,UAAU,CAAA;YACV,MAAM,CAAC;gBACH,KAAK,EAAE,CAAC;gBACR,KAAK,EAAE,cAAM,OAAA,KAAI,EAAJ,CAAI;gBACjB,GAAG,gBAAK,MAAM,CAAC,cAAc,CAAA,CAAC,CAAC;aAClC,CAAC;QACN,CAAC;QACD,IAAI;YACA,MAAM,CAAC,IAAI,CAAC;IACpB,CAAC;IACL,QAAC;AAAD,CAAC,AAjBD,CAAgB,CAAC,GAiBhB"} \ No newline at end of file +{"version":3,"file":"derivedClassConstructorWithExplicitReturns01.js","sourceRoot":"","sources":["derivedClassConstructorWithExplicitReturns01.ts"],"names":[],"mappings":";;;;;;;;;;AAAA;IAKI,WAAY,KAAa;QAJzB,UAAK,GAAG,EAAE,CAAC;QAKP,MAAM,CAAC;YACH,KAAK,EAAE,KAAK;YACZ,GAAG;gBACC,MAAM,CAAC,8BAA8B,CAAC;YAC1C,CAAC;SACJ,CAAA;IACL,CAAC;IATD,eAAG,GAAH,cAAQ,MAAM,CAAC,uBAAuB,CAAC,CAAC,CAAC;IAU7C,QAAC;AAAD,CAAC,AAbD,IAaC;AAED;IAAgB,qBAAC;IAGb,WAAY,CAAO;QAAP,kBAAA,EAAA,OAAO;QAAnB,YACI,kBAAM,CAAC,CAAC,SAYX;QAfD,WAAK,GAAG,cAAM,OAAA,KAAI,EAAJ,CAAI,CAAC;QAKf,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;YACtB,UAAU,CAAA;YACV,MAAM,CAAC;gBACH,KAAK,EAAE,CAAC;gBACR,KAAK,EAAE,cAAM,OAAA,KAAI,EAAJ,CAAI;gBACjB,GAAG,gBAAK,MAAM,CAAC,cAAc,CAAA,CAAC,CAAC;aAClC,CAAC;QACN,CAAC;QACD,IAAI;YACA,MAAM,CAAC,IAAI,CAAC;IACpB,CAAC;IACL,QAAC;AAAD,CAAC,AAjBD,CAAgB,CAAC,GAiBhB"} \ No newline at end of file diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.sourcemap.txt b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.sourcemap.txt index 42d415430e258..76da9ac8a5a99 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.sourcemap.txt +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.sourcemap.txt @@ -21,9 +21,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts >>>var C = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(11, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(11, 1) Source(1, 1) + SourceIndex(0) --- >>> function C(value) { 1->^^^^ @@ -38,9 +37,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > constructor( 3 > value: number -1->Emitted(12, 5) Source(7, 5) + SourceIndex(0) -2 >Emitted(12, 16) Source(7, 17) + SourceIndex(0) -3 >Emitted(12, 21) Source(7, 30) + SourceIndex(0) +1->Emitted(12, 5) Source(6, 5) + SourceIndex(0) +2 >Emitted(12, 16) Source(6, 17) + SourceIndex(0) +3 >Emitted(12, 21) Source(6, 30) + SourceIndex(0) --- >>> this.cProp = 10; 1->^^^^^^^^ @@ -53,11 +52,11 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 3 > = 4 > 10 5 > ; -1->Emitted(13, 9) Source(3, 5) + SourceIndex(0) -2 >Emitted(13, 19) Source(3, 10) + SourceIndex(0) -3 >Emitted(13, 22) Source(3, 13) + SourceIndex(0) -4 >Emitted(13, 24) Source(3, 15) + SourceIndex(0) -5 >Emitted(13, 25) Source(3, 16) + SourceIndex(0) +1->Emitted(13, 9) Source(2, 5) + SourceIndex(0) +2 >Emitted(13, 19) Source(2, 10) + SourceIndex(0) +3 >Emitted(13, 22) Source(2, 13) + SourceIndex(0) +4 >Emitted(13, 24) Source(2, 15) + SourceIndex(0) +5 >Emitted(13, 25) Source(2, 16) + SourceIndex(0) --- >>> return { 1 >^^^^^^^^ @@ -72,9 +71,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > return 3 > -1 >Emitted(14, 9) Source(8, 9) + SourceIndex(0) -2 >Emitted(14, 15) Source(8, 15) + SourceIndex(0) -3 >Emitted(14, 16) Source(8, 16) + SourceIndex(0) +1 >Emitted(14, 9) Source(7, 9) + SourceIndex(0) +2 >Emitted(14, 15) Source(7, 15) + SourceIndex(0) +3 >Emitted(14, 16) Source(7, 16) + SourceIndex(0) --- >>> cProp: value, 1->^^^^^^^^^^^^ @@ -87,10 +86,10 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 2 > cProp 3 > : 4 > value -1->Emitted(15, 13) Source(9, 13) + SourceIndex(0) -2 >Emitted(15, 18) Source(9, 18) + SourceIndex(0) -3 >Emitted(15, 20) Source(9, 20) + SourceIndex(0) -4 >Emitted(15, 25) Source(9, 25) + SourceIndex(0) +1->Emitted(15, 13) Source(8, 13) + SourceIndex(0) +2 >Emitted(15, 18) Source(8, 18) + SourceIndex(0) +3 >Emitted(15, 20) Source(8, 20) + SourceIndex(0) +4 >Emitted(15, 25) Source(8, 25) + SourceIndex(0) --- >>> foo: function () { 1->^^^^^^^^^^^^ @@ -99,8 +98,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1->, > 2 > foo -1->Emitted(16, 13) Source(10, 13) + SourceIndex(0) -2 >Emitted(16, 16) Source(10, 16) + SourceIndex(0) +1->Emitted(16, 13) Source(9, 13) + SourceIndex(0) +2 >Emitted(16, 16) Source(9, 16) + SourceIndex(0) --- >>> return "well this looks kinda C-ish."; 1->^^^^^^^^^^^^^^^^ @@ -114,11 +113,11 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 3 > 4 > "well this looks kinda C-ish." 5 > ; -1->Emitted(17, 17) Source(11, 17) + SourceIndex(0) -2 >Emitted(17, 23) Source(11, 23) + SourceIndex(0) -3 >Emitted(17, 24) Source(11, 24) + SourceIndex(0) -4 >Emitted(17, 54) Source(11, 54) + SourceIndex(0) -5 >Emitted(17, 55) Source(11, 55) + SourceIndex(0) +1->Emitted(17, 17) Source(10, 17) + SourceIndex(0) +2 >Emitted(17, 23) Source(10, 23) + SourceIndex(0) +3 >Emitted(17, 24) Source(10, 24) + SourceIndex(0) +4 >Emitted(17, 54) Source(10, 54) + SourceIndex(0) +5 >Emitted(17, 55) Source(10, 55) + SourceIndex(0) --- >>> } 1 >^^^^^^^^^^^^ @@ -126,8 +125,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > 2 > } -1 >Emitted(18, 13) Source(12, 13) + SourceIndex(0) -2 >Emitted(18, 14) Source(12, 14) + SourceIndex(0) +1 >Emitted(18, 13) Source(11, 13) + SourceIndex(0) +2 >Emitted(18, 14) Source(11, 14) + SourceIndex(0) --- >>> }; 1 >^^^^^^^^^ @@ -135,8 +134,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > } 2 > -1 >Emitted(19, 10) Source(13, 10) + SourceIndex(0) -2 >Emitted(19, 11) Source(13, 10) + SourceIndex(0) +1 >Emitted(19, 10) Source(12, 10) + SourceIndex(0) +2 >Emitted(19, 11) Source(12, 10) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -145,8 +144,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > 2 > } -1 >Emitted(20, 5) Source(14, 5) + SourceIndex(0) -2 >Emitted(20, 6) Source(14, 6) + SourceIndex(0) +1 >Emitted(20, 5) Source(13, 5) + SourceIndex(0) +2 >Emitted(20, 6) Source(13, 6) + SourceIndex(0) --- >>> C.prototype.foo = function () { return "this never gets used."; }; 1->^^^^ @@ -169,16 +168,16 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 8 > ; 9 > 10> } -1->Emitted(21, 5) Source(5, 5) + SourceIndex(0) -2 >Emitted(21, 20) Source(5, 8) + SourceIndex(0) -3 >Emitted(21, 23) Source(5, 5) + SourceIndex(0) -4 >Emitted(21, 37) Source(5, 13) + SourceIndex(0) -5 >Emitted(21, 43) Source(5, 19) + SourceIndex(0) -6 >Emitted(21, 44) Source(5, 20) + SourceIndex(0) -7 >Emitted(21, 67) Source(5, 43) + SourceIndex(0) -8 >Emitted(21, 68) Source(5, 44) + SourceIndex(0) -9 >Emitted(21, 69) Source(5, 45) + SourceIndex(0) -10>Emitted(21, 70) Source(5, 46) + SourceIndex(0) +1->Emitted(21, 5) Source(4, 5) + SourceIndex(0) +2 >Emitted(21, 20) Source(4, 8) + SourceIndex(0) +3 >Emitted(21, 23) Source(4, 5) + SourceIndex(0) +4 >Emitted(21, 37) Source(4, 13) + SourceIndex(0) +5 >Emitted(21, 43) Source(4, 19) + SourceIndex(0) +6 >Emitted(21, 44) Source(4, 20) + SourceIndex(0) +7 >Emitted(21, 67) Source(4, 43) + SourceIndex(0) +8 >Emitted(21, 68) Source(4, 44) + SourceIndex(0) +9 >Emitted(21, 69) Source(4, 45) + SourceIndex(0) +10>Emitted(21, 70) Source(4, 46) + SourceIndex(0) --- >>> return C; 1 >^^^^ @@ -195,8 +194,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > } > 2 > } -1 >Emitted(22, 5) Source(15, 1) + SourceIndex(0) -2 >Emitted(22, 13) Source(15, 2) + SourceIndex(0) +1 >Emitted(22, 5) Source(14, 1) + SourceIndex(0) +2 >Emitted(22, 13) Source(14, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -221,10 +220,10 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > } > } > } -1 >Emitted(23, 1) Source(15, 1) + SourceIndex(0) -2 >Emitted(23, 2) Source(15, 2) + SourceIndex(0) -3 >Emitted(23, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(23, 6) Source(15, 2) + SourceIndex(0) +1 >Emitted(23, 1) Source(14, 1) + SourceIndex(0) +2 >Emitted(23, 2) Source(14, 2) + SourceIndex(0) +3 >Emitted(23, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(23, 6) Source(14, 2) + SourceIndex(0) --- >>>var D = (function (_super) { 1-> @@ -232,15 +231,15 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1-> > > -1->Emitted(24, 1) Source(17, 1) + SourceIndex(0) +1->Emitted(24, 1) Source(16, 1) + SourceIndex(0) --- >>> __extends(D, _super); 1->^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^ 1->class D extends 2 > C -1->Emitted(25, 5) Source(17, 17) + SourceIndex(0) -2 >Emitted(25, 26) Source(17, 18) + SourceIndex(0) +1->Emitted(25, 5) Source(16, 17) + SourceIndex(0) +2 >Emitted(25, 26) Source(16, 18) + SourceIndex(0) --- >>> function D(a) { 1 >^^^^ @@ -253,9 +252,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > constructor( 3 > a = 100 -1 >Emitted(26, 5) Source(20, 5) + SourceIndex(0) -2 >Emitted(26, 16) Source(20, 17) + SourceIndex(0) -3 >Emitted(26, 17) Source(20, 24) + SourceIndex(0) +1 >Emitted(26, 5) Source(19, 5) + SourceIndex(0) +2 >Emitted(26, 16) Source(19, 17) + SourceIndex(0) +3 >Emitted(26, 17) Source(19, 24) + SourceIndex(0) --- >>> if (a === void 0) { a = 100; } 1->^^^^^^^^ @@ -267,10 +266,10 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 2 > 3 > 4 > a = 100 -1->Emitted(27, 9) Source(20, 17) + SourceIndex(0) -2 >Emitted(27, 27) Source(20, 17) + SourceIndex(0) -3 >Emitted(27, 29) Source(20, 17) + SourceIndex(0) -4 >Emitted(27, 36) Source(20, 24) + SourceIndex(0) +1->Emitted(27, 9) Source(19, 17) + SourceIndex(0) +2 >Emitted(27, 27) Source(19, 17) + SourceIndex(0) +3 >Emitted(27, 29) Source(19, 17) + SourceIndex(0) +4 >Emitted(27, 36) Source(19, 24) + SourceIndex(0) --- >>> var _this = _super.call(this, a) || this; 1->^^^^^^^^ @@ -299,12 +298,12 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > else > return null; > } -1->Emitted(28, 9) Source(20, 5) + SourceIndex(0) -2 >Emitted(28, 21) Source(21, 9) + SourceIndex(0) -3 >Emitted(28, 39) Source(21, 15) + SourceIndex(0) -4 >Emitted(28, 40) Source(21, 16) + SourceIndex(0) -5 >Emitted(28, 41) Source(21, 17) + SourceIndex(0) -6 >Emitted(28, 50) Source(33, 6) + SourceIndex(0) +1->Emitted(28, 9) Source(19, 5) + SourceIndex(0) +2 >Emitted(28, 21) Source(20, 9) + SourceIndex(0) +3 >Emitted(28, 39) Source(20, 15) + SourceIndex(0) +4 >Emitted(28, 40) Source(20, 16) + SourceIndex(0) +5 >Emitted(28, 41) Source(20, 17) + SourceIndex(0) +6 >Emitted(28, 50) Source(32, 6) + SourceIndex(0) --- >>> _this.dProp = function () { return _this; }; 1->^^^^^^^^ @@ -325,15 +324,15 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 7 > 8 > this 9 > ; -1->Emitted(29, 9) Source(18, 5) + SourceIndex(0) -2 >Emitted(29, 20) Source(18, 10) + SourceIndex(0) -3 >Emitted(29, 23) Source(18, 13) + SourceIndex(0) -4 >Emitted(29, 37) Source(18, 19) + SourceIndex(0) -5 >Emitted(29, 44) Source(18, 19) + SourceIndex(0) -6 >Emitted(29, 49) Source(18, 23) + SourceIndex(0) -7 >Emitted(29, 51) Source(18, 19) + SourceIndex(0) -8 >Emitted(29, 52) Source(18, 23) + SourceIndex(0) -9 >Emitted(29, 53) Source(18, 24) + SourceIndex(0) +1->Emitted(29, 9) Source(17, 5) + SourceIndex(0) +2 >Emitted(29, 20) Source(17, 10) + SourceIndex(0) +3 >Emitted(29, 23) Source(17, 13) + SourceIndex(0) +4 >Emitted(29, 37) Source(17, 19) + SourceIndex(0) +5 >Emitted(29, 44) Source(17, 19) + SourceIndex(0) +6 >Emitted(29, 49) Source(17, 23) + SourceIndex(0) +7 >Emitted(29, 51) Source(17, 19) + SourceIndex(0) +8 >Emitted(29, 52) Source(17, 23) + SourceIndex(0) +9 >Emitted(29, 53) Source(17, 24) + SourceIndex(0) --- >>> if (Math.random() < 0.5) { 1 >^^^^^^^^ @@ -367,19 +366,19 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 11> ) 12> 13> { -1 >Emitted(30, 9) Source(23, 9) + SourceIndex(0) -2 >Emitted(30, 11) Source(23, 11) + SourceIndex(0) -3 >Emitted(30, 12) Source(23, 12) + SourceIndex(0) -4 >Emitted(30, 13) Source(23, 13) + SourceIndex(0) -5 >Emitted(30, 17) Source(23, 17) + SourceIndex(0) -6 >Emitted(30, 18) Source(23, 18) + SourceIndex(0) -7 >Emitted(30, 24) Source(23, 24) + SourceIndex(0) -8 >Emitted(30, 26) Source(23, 26) + SourceIndex(0) -9 >Emitted(30, 29) Source(23, 29) + SourceIndex(0) -10>Emitted(30, 32) Source(23, 32) + SourceIndex(0) -11>Emitted(30, 33) Source(23, 33) + SourceIndex(0) -12>Emitted(30, 34) Source(23, 34) + SourceIndex(0) -13>Emitted(30, 35) Source(23, 35) + SourceIndex(0) +1 >Emitted(30, 9) Source(22, 9) + SourceIndex(0) +2 >Emitted(30, 11) Source(22, 11) + SourceIndex(0) +3 >Emitted(30, 12) Source(22, 12) + SourceIndex(0) +4 >Emitted(30, 13) Source(22, 13) + SourceIndex(0) +5 >Emitted(30, 17) Source(22, 17) + SourceIndex(0) +6 >Emitted(30, 18) Source(22, 18) + SourceIndex(0) +7 >Emitted(30, 24) Source(22, 24) + SourceIndex(0) +8 >Emitted(30, 26) Source(22, 26) + SourceIndex(0) +9 >Emitted(30, 29) Source(22, 29) + SourceIndex(0) +10>Emitted(30, 32) Source(22, 32) + SourceIndex(0) +11>Emitted(30, 33) Source(22, 33) + SourceIndex(0) +12>Emitted(30, 34) Source(22, 34) + SourceIndex(0) +13>Emitted(30, 35) Source(22, 35) + SourceIndex(0) --- >>> "You win!"; 1 >^^^^^^^^^^^^ @@ -389,9 +388,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > "You win!" 3 > -1 >Emitted(31, 13) Source(24, 13) + SourceIndex(0) -2 >Emitted(31, 23) Source(24, 23) + SourceIndex(0) -3 >Emitted(31, 24) Source(24, 23) + SourceIndex(0) +1 >Emitted(31, 13) Source(23, 13) + SourceIndex(0) +2 >Emitted(31, 23) Source(23, 23) + SourceIndex(0) +3 >Emitted(31, 24) Source(23, 23) + SourceIndex(0) --- >>> return { 1 >^^^^^^^^^^^^ @@ -402,9 +401,9 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > 2 > return 3 > -1 >Emitted(32, 13) Source(25, 13) + SourceIndex(0) -2 >Emitted(32, 19) Source(25, 19) + SourceIndex(0) -3 >Emitted(32, 20) Source(25, 20) + SourceIndex(0) +1 >Emitted(32, 13) Source(24, 13) + SourceIndex(0) +2 >Emitted(32, 19) Source(24, 19) + SourceIndex(0) +3 >Emitted(32, 20) Source(24, 20) + SourceIndex(0) --- >>> cProp: 1, 1->^^^^^^^^^^^^^^^^ @@ -417,10 +416,10 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 2 > cProp 3 > : 4 > 1 -1->Emitted(33, 17) Source(26, 17) + SourceIndex(0) -2 >Emitted(33, 22) Source(26, 22) + SourceIndex(0) -3 >Emitted(33, 24) Source(26, 24) + SourceIndex(0) -4 >Emitted(33, 25) Source(26, 25) + SourceIndex(0) +1->Emitted(33, 17) Source(25, 17) + SourceIndex(0) +2 >Emitted(33, 22) Source(25, 22) + SourceIndex(0) +3 >Emitted(33, 24) Source(25, 24) + SourceIndex(0) +4 >Emitted(33, 25) Source(25, 25) + SourceIndex(0) --- >>> dProp: function () { return _this; }, 1->^^^^^^^^^^^^^^^^ @@ -441,14 +440,14 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 6 > this 7 > 8 > this -1->Emitted(34, 17) Source(27, 17) + SourceIndex(0) -2 >Emitted(34, 22) Source(27, 22) + SourceIndex(0) -3 >Emitted(34, 24) Source(27, 24) + SourceIndex(0) -4 >Emitted(34, 38) Source(27, 30) + SourceIndex(0) -5 >Emitted(34, 45) Source(27, 30) + SourceIndex(0) -6 >Emitted(34, 50) Source(27, 34) + SourceIndex(0) -7 >Emitted(34, 52) Source(27, 30) + SourceIndex(0) -8 >Emitted(34, 53) Source(27, 34) + SourceIndex(0) +1->Emitted(34, 17) Source(26, 17) + SourceIndex(0) +2 >Emitted(34, 22) Source(26, 22) + SourceIndex(0) +3 >Emitted(34, 24) Source(26, 24) + SourceIndex(0) +4 >Emitted(34, 38) Source(26, 30) + SourceIndex(0) +5 >Emitted(34, 45) Source(26, 30) + SourceIndex(0) +6 >Emitted(34, 50) Source(26, 34) + SourceIndex(0) +7 >Emitted(34, 52) Source(26, 30) + SourceIndex(0) +8 >Emitted(34, 53) Source(26, 34) + SourceIndex(0) --- >>> foo: function () { return "You win!!!!!"; } 1->^^^^^^^^^^^^^^^^ @@ -470,15 +469,15 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 7 > 8 > 9 > } -1->Emitted(35, 17) Source(28, 17) + SourceIndex(0) -2 >Emitted(35, 20) Source(28, 20) + SourceIndex(0) -3 >Emitted(35, 36) Source(28, 25) + SourceIndex(0) -4 >Emitted(35, 42) Source(28, 31) + SourceIndex(0) -5 >Emitted(35, 43) Source(28, 32) + SourceIndex(0) -6 >Emitted(35, 57) Source(28, 46) + SourceIndex(0) -7 >Emitted(35, 58) Source(28, 46) + SourceIndex(0) -8 >Emitted(35, 59) Source(28, 47) + SourceIndex(0) -9 >Emitted(35, 60) Source(28, 48) + SourceIndex(0) +1->Emitted(35, 17) Source(27, 17) + SourceIndex(0) +2 >Emitted(35, 20) Source(27, 20) + SourceIndex(0) +3 >Emitted(35, 36) Source(27, 25) + SourceIndex(0) +4 >Emitted(35, 42) Source(27, 31) + SourceIndex(0) +5 >Emitted(35, 43) Source(27, 32) + SourceIndex(0) +6 >Emitted(35, 57) Source(27, 46) + SourceIndex(0) +7 >Emitted(35, 58) Source(27, 46) + SourceIndex(0) +8 >Emitted(35, 59) Source(27, 47) + SourceIndex(0) +9 >Emitted(35, 60) Source(27, 48) + SourceIndex(0) --- >>> }; 1 >^^^^^^^^^^^^^ @@ -486,8 +485,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > } 2 > ; -1 >Emitted(36, 14) Source(29, 14) + SourceIndex(0) -2 >Emitted(36, 15) Source(29, 15) + SourceIndex(0) +1 >Emitted(36, 14) Source(28, 14) + SourceIndex(0) +2 >Emitted(36, 15) Source(28, 15) + SourceIndex(0) --- >>> } 1 >^^^^^^^^ @@ -496,8 +495,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > 2 > } -1 >Emitted(37, 9) Source(30, 9) + SourceIndex(0) -2 >Emitted(37, 10) Source(30, 10) + SourceIndex(0) +1 >Emitted(37, 9) Source(29, 9) + SourceIndex(0) +2 >Emitted(37, 10) Source(29, 10) + SourceIndex(0) --- >>> else 1->^^^^^^^^ @@ -506,8 +505,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1-> > 2 > else -1->Emitted(38, 9) Source(31, 9) + SourceIndex(0) -2 >Emitted(38, 13) Source(31, 13) + SourceIndex(0) +1->Emitted(38, 9) Source(30, 9) + SourceIndex(0) +2 >Emitted(38, 13) Source(30, 13) + SourceIndex(0) --- >>> return null; 1->^^^^^^^^^^^^ @@ -521,11 +520,11 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 3 > 4 > null 5 > ; -1->Emitted(39, 13) Source(32, 13) + SourceIndex(0) -2 >Emitted(39, 19) Source(32, 19) + SourceIndex(0) -3 >Emitted(39, 20) Source(32, 20) + SourceIndex(0) -4 >Emitted(39, 24) Source(32, 24) + SourceIndex(0) -5 >Emitted(39, 25) Source(32, 25) + SourceIndex(0) +1->Emitted(39, 13) Source(31, 13) + SourceIndex(0) +2 >Emitted(39, 19) Source(31, 19) + SourceIndex(0) +3 >Emitted(39, 20) Source(31, 20) + SourceIndex(0) +4 >Emitted(39, 24) Source(31, 24) + SourceIndex(0) +5 >Emitted(39, 25) Source(31, 25) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -534,8 +533,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1 > > 2 > } -1 >Emitted(40, 5) Source(33, 5) + SourceIndex(0) -2 >Emitted(40, 6) Source(33, 6) + SourceIndex(0) +1 >Emitted(40, 5) Source(32, 5) + SourceIndex(0) +2 >Emitted(40, 6) Source(32, 6) + SourceIndex(0) --- >>> return D; 1->^^^^ @@ -543,8 +542,8 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts 1-> > 2 > } -1->Emitted(41, 5) Source(34, 1) + SourceIndex(0) -2 >Emitted(41, 13) Source(34, 2) + SourceIndex(0) +1->Emitted(41, 5) Source(33, 1) + SourceIndex(0) +2 >Emitted(41, 13) Source(33, 2) + SourceIndex(0) --- >>>}(C)); 1 > @@ -577,11 +576,11 @@ sourceFile:derivedClassConstructorWithExplicitReturns01.ts > return null; > } > } -1 >Emitted(42, 1) Source(34, 1) + SourceIndex(0) -2 >Emitted(42, 2) Source(34, 2) + SourceIndex(0) -3 >Emitted(42, 2) Source(17, 1) + SourceIndex(0) -4 >Emitted(42, 3) Source(17, 17) + SourceIndex(0) -5 >Emitted(42, 4) Source(17, 18) + SourceIndex(0) -6 >Emitted(42, 7) Source(34, 2) + SourceIndex(0) +1 >Emitted(42, 1) Source(33, 1) + SourceIndex(0) +2 >Emitted(42, 2) Source(33, 2) + SourceIndex(0) +3 >Emitted(42, 2) Source(16, 1) + SourceIndex(0) +4 >Emitted(42, 3) Source(16, 17) + SourceIndex(0) +5 >Emitted(42, 4) Source(16, 18) + SourceIndex(0) +6 >Emitted(42, 7) Source(33, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=derivedClassConstructorWithExplicitReturns01.js.map \ No newline at end of file diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.symbols b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.symbols index ee043fcfe712d..a8545de2ba1c7 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.symbols +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.symbols @@ -1,24 +1,23 @@ === tests/cases/compiler/derivedClassConstructorWithExplicitReturns01.ts === - class C { >C : Symbol(C, Decl(derivedClassConstructorWithExplicitReturns01.ts, 0, 0)) cProp = 10; ->cProp : Symbol(C.cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 1, 9)) +>cProp : Symbol(C.cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 0, 9)) foo() { return "this never gets used."; } ->foo : Symbol(C.foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 2, 15)) +>foo : Symbol(C.foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 1, 15)) constructor(value: number) { ->value : Symbol(value, Decl(derivedClassConstructorWithExplicitReturns01.ts, 6, 16)) +>value : Symbol(value, Decl(derivedClassConstructorWithExplicitReturns01.ts, 5, 16)) return { cProp: value, ->cProp : Symbol(cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 7, 16)) ->value : Symbol(value, Decl(derivedClassConstructorWithExplicitReturns01.ts, 6, 16)) +>cProp : Symbol(cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 6, 16)) +>value : Symbol(value, Decl(derivedClassConstructorWithExplicitReturns01.ts, 5, 16)) foo() { ->foo : Symbol(foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 8, 25)) +>foo : Symbol(foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 7, 25)) return "well this looks kinda C-ish."; } @@ -27,19 +26,19 @@ class C { } class D extends C { ->D : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 14, 1)) +>D : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 13, 1)) >C : Symbol(C, Decl(derivedClassConstructorWithExplicitReturns01.ts, 0, 0)) dProp = () => this; ->dProp : Symbol(D.dProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 16, 19)) ->this : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 14, 1)) +>dProp : Symbol(D.dProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 15, 19)) +>this : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 13, 1)) constructor(a = 100) { ->a : Symbol(a, Decl(derivedClassConstructorWithExplicitReturns01.ts, 19, 16)) +>a : Symbol(a, Decl(derivedClassConstructorWithExplicitReturns01.ts, 18, 16)) super(a); >super : Symbol(C, Decl(derivedClassConstructorWithExplicitReturns01.ts, 0, 0)) ->a : Symbol(a, Decl(derivedClassConstructorWithExplicitReturns01.ts, 19, 16)) +>a : Symbol(a, Decl(derivedClassConstructorWithExplicitReturns01.ts, 18, 16)) if (Math.random() < 0.5) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -49,14 +48,14 @@ class D extends C { "You win!" return { cProp: 1, ->cProp : Symbol(cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 24, 20)) +>cProp : Symbol(cProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 23, 20)) dProp: () => this, ->dProp : Symbol(dProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 25, 25)) ->this : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 14, 1)) +>dProp : Symbol(dProp, Decl(derivedClassConstructorWithExplicitReturns01.ts, 24, 25)) +>this : Symbol(D, Decl(derivedClassConstructorWithExplicitReturns01.ts, 13, 1)) foo() { return "You win!!!!!" } ->foo : Symbol(foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 26, 34)) +>foo : Symbol(foo, Decl(derivedClassConstructorWithExplicitReturns01.ts, 25, 34)) }; } diff --git a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.types b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.types index d361e783ef0fc..dbcac43d5bd75 100644 --- a/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.types +++ b/tests/baselines/reference/derivedClassConstructorWithExplicitReturns01.types @@ -1,5 +1,4 @@ === tests/cases/compiler/derivedClassConstructorWithExplicitReturns01.ts === - class C { >C : C diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers.js b/tests/baselines/reference/derivedClassOverridesProtectedMembers.js index 9230a295f5bf4..7369354ffd96d 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers.js +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers.js @@ -1,5 +1,4 @@ //// [derivedClassOverridesProtectedMembers.ts] - var x: { foo: string; } var y: { foo: string; bar: string; } diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers.symbols b/tests/baselines/reference/derivedClassOverridesProtectedMembers.symbols index 690916db87ca7..fbe2b87bcb661 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers.symbols +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers.symbols @@ -1,122 +1,121 @@ === tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers.ts === - var x: { foo: string; } ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) ->foo : Symbol(foo, Decl(derivedClassOverridesProtectedMembers.ts, 1, 8)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) +>foo : Symbol(foo, Decl(derivedClassOverridesProtectedMembers.ts, 0, 8)) var y: { foo: string; bar: string; } ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) ->foo : Symbol(foo, Decl(derivedClassOverridesProtectedMembers.ts, 2, 8)) ->bar : Symbol(bar, Decl(derivedClassOverridesProtectedMembers.ts, 2, 21)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>foo : Symbol(foo, Decl(derivedClassOverridesProtectedMembers.ts, 1, 8)) +>bar : Symbol(bar, Decl(derivedClassOverridesProtectedMembers.ts, 1, 21)) class Base { ->Base : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 2, 36)) +>Base : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 1, 36)) protected a: typeof x; ->a : Symbol(Base.a, Decl(derivedClassOverridesProtectedMembers.ts, 4, 12)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>a : Symbol(Base.a, Decl(derivedClassOverridesProtectedMembers.ts, 3, 12)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected b(a: typeof x) { } ->b : Symbol(Base.b, Decl(derivedClassOverridesProtectedMembers.ts, 5, 26)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 6, 16)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>b : Symbol(Base.b, Decl(derivedClassOverridesProtectedMembers.ts, 4, 26)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 5, 16)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected get c() { return x; } ->c : Symbol(Base.c, Decl(derivedClassOverridesProtectedMembers.ts, 6, 32), Decl(derivedClassOverridesProtectedMembers.ts, 7, 35)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>c : Symbol(Base.c, Decl(derivedClassOverridesProtectedMembers.ts, 5, 32), Decl(derivedClassOverridesProtectedMembers.ts, 6, 35)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected set c(v: typeof x) { } ->c : Symbol(Base.c, Decl(derivedClassOverridesProtectedMembers.ts, 6, 32), Decl(derivedClassOverridesProtectedMembers.ts, 7, 35)) ->v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 8, 20)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>c : Symbol(Base.c, Decl(derivedClassOverridesProtectedMembers.ts, 5, 32), Decl(derivedClassOverridesProtectedMembers.ts, 6, 35)) +>v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 7, 20)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected d: (a: typeof x) => void; ->d : Symbol(Base.d, Decl(derivedClassOverridesProtectedMembers.ts, 8, 36)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 9, 18)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>d : Symbol(Base.d, Decl(derivedClassOverridesProtectedMembers.ts, 7, 36)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 8, 18)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static r: typeof x; ->r : Symbol(Base.r, Decl(derivedClassOverridesProtectedMembers.ts, 9, 39)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>r : Symbol(Base.r, Decl(derivedClassOverridesProtectedMembers.ts, 8, 39)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static s(a: typeof x) { } ->s : Symbol(Base.s, Decl(derivedClassOverridesProtectedMembers.ts, 11, 33)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 12, 23)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>s : Symbol(Base.s, Decl(derivedClassOverridesProtectedMembers.ts, 10, 33)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 11, 23)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static get t() { return x; } ->t : Symbol(Base.t, Decl(derivedClassOverridesProtectedMembers.ts, 12, 39), Decl(derivedClassOverridesProtectedMembers.ts, 13, 42)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>t : Symbol(Base.t, Decl(derivedClassOverridesProtectedMembers.ts, 11, 39), Decl(derivedClassOverridesProtectedMembers.ts, 12, 42)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static set t(v: typeof x) { } ->t : Symbol(Base.t, Decl(derivedClassOverridesProtectedMembers.ts, 12, 39), Decl(derivedClassOverridesProtectedMembers.ts, 13, 42)) ->v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 14, 27)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>t : Symbol(Base.t, Decl(derivedClassOverridesProtectedMembers.ts, 11, 39), Decl(derivedClassOverridesProtectedMembers.ts, 12, 42)) +>v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 13, 27)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) protected static u: (a: typeof x) => void; ->u : Symbol(Base.u, Decl(derivedClassOverridesProtectedMembers.ts, 14, 43)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 15, 25)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>u : Symbol(Base.u, Decl(derivedClassOverridesProtectedMembers.ts, 13, 43)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 14, 25)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) constructor(a: typeof x) { } ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 17, 16)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 16, 16)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) } class Derived extends Base { ->Derived : Symbol(Derived, Decl(derivedClassOverridesProtectedMembers.ts, 18, 1)) ->Base : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 2, 36)) +>Derived : Symbol(Derived, Decl(derivedClassOverridesProtectedMembers.ts, 17, 1)) +>Base : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 1, 36)) protected a: typeof y; ->a : Symbol(Derived.a, Decl(derivedClassOverridesProtectedMembers.ts, 20, 28)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>a : Symbol(Derived.a, Decl(derivedClassOverridesProtectedMembers.ts, 19, 28)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected b(a: typeof y) { } ->b : Symbol(Derived.b, Decl(derivedClassOverridesProtectedMembers.ts, 21, 26)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 22, 16)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>b : Symbol(Derived.b, Decl(derivedClassOverridesProtectedMembers.ts, 20, 26)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 21, 16)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected get c() { return y; } ->c : Symbol(Derived.c, Decl(derivedClassOverridesProtectedMembers.ts, 22, 32), Decl(derivedClassOverridesProtectedMembers.ts, 23, 35)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>c : Symbol(Derived.c, Decl(derivedClassOverridesProtectedMembers.ts, 21, 32), Decl(derivedClassOverridesProtectedMembers.ts, 22, 35)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected set c(v: typeof y) { } ->c : Symbol(Derived.c, Decl(derivedClassOverridesProtectedMembers.ts, 22, 32), Decl(derivedClassOverridesProtectedMembers.ts, 23, 35)) ->v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 24, 20)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>c : Symbol(Derived.c, Decl(derivedClassOverridesProtectedMembers.ts, 21, 32), Decl(derivedClassOverridesProtectedMembers.ts, 22, 35)) +>v : Symbol(v, Decl(derivedClassOverridesProtectedMembers.ts, 23, 20)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected d: (a: typeof y) => void; ->d : Symbol(Derived.d, Decl(derivedClassOverridesProtectedMembers.ts, 24, 36)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 25, 18)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>d : Symbol(Derived.d, Decl(derivedClassOverridesProtectedMembers.ts, 23, 36)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 24, 18)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static r: typeof y; ->r : Symbol(Derived.r, Decl(derivedClassOverridesProtectedMembers.ts, 25, 39)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>r : Symbol(Derived.r, Decl(derivedClassOverridesProtectedMembers.ts, 24, 39)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static s(a: typeof y) { } ->s : Symbol(Derived.s, Decl(derivedClassOverridesProtectedMembers.ts, 27, 33)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 28, 23)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>s : Symbol(Derived.s, Decl(derivedClassOverridesProtectedMembers.ts, 26, 33)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 27, 23)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static get t() { return y; } ->t : Symbol(Derived.t, Decl(derivedClassOverridesProtectedMembers.ts, 28, 39), Decl(derivedClassOverridesProtectedMembers.ts, 29, 42)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>t : Symbol(Derived.t, Decl(derivedClassOverridesProtectedMembers.ts, 27, 39), Decl(derivedClassOverridesProtectedMembers.ts, 28, 42)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static set t(a: typeof y) { } ->t : Symbol(Derived.t, Decl(derivedClassOverridesProtectedMembers.ts, 28, 39), Decl(derivedClassOverridesProtectedMembers.ts, 29, 42)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 30, 27)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>t : Symbol(Derived.t, Decl(derivedClassOverridesProtectedMembers.ts, 27, 39), Decl(derivedClassOverridesProtectedMembers.ts, 28, 42)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 29, 27)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) protected static u: (a: typeof y) => void; ->u : Symbol(Derived.u, Decl(derivedClassOverridesProtectedMembers.ts, 30, 43)) ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 31, 25)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) +>u : Symbol(Derived.u, Decl(derivedClassOverridesProtectedMembers.ts, 29, 43)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 30, 25)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) constructor(a: typeof y) { super(x) } ->a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 33, 16)) ->y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 2, 3)) ->super : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 2, 36)) ->x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>a : Symbol(a, Decl(derivedClassOverridesProtectedMembers.ts, 32, 16)) +>y : Symbol(y, Decl(derivedClassOverridesProtectedMembers.ts, 1, 3)) +>super : Symbol(Base, Decl(derivedClassOverridesProtectedMembers.ts, 1, 36)) +>x : Symbol(x, Decl(derivedClassOverridesProtectedMembers.ts, 0, 3)) } diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers.types b/tests/baselines/reference/derivedClassOverridesProtectedMembers.types index 2695cbabe3461..32aca9dd5cb06 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers.types +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers.ts === - var x: { foo: string; } >x : { foo: string; } >foo : string diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers3.errors.txt b/tests/baselines/reference/derivedClassOverridesProtectedMembers3.errors.txt index a9762ce03ec71..faf228e8d55c2 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers3.errors.txt +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers3.errors.txt @@ -1,27 +1,26 @@ -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(23,7): error TS2415: Class 'Derived1' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(22,7): error TS2415: Class 'Derived1' incorrectly extends base class 'Base'. Property 'a' is protected in type 'Derived1' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(28,7): error TS2415: Class 'Derived2' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(27,7): error TS2415: Class 'Derived2' incorrectly extends base class 'Base'. Property 'b' is protected in type 'Derived2' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(33,7): error TS2415: Class 'Derived3' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(32,7): error TS2415: Class 'Derived3' incorrectly extends base class 'Base'. Property 'c' is protected in type 'Derived3' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(38,7): error TS2415: Class 'Derived4' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(37,7): error TS2415: Class 'Derived4' incorrectly extends base class 'Base'. Property 'c' is protected in type 'Derived4' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(43,7): error TS2415: Class 'Derived5' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(42,7): error TS2415: Class 'Derived5' incorrectly extends base class 'Base'. Property 'd' is protected in type 'Derived5' but public in type 'Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(48,7): error TS2417: Class static side 'typeof Derived6' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(47,7): error TS2417: Class static side 'typeof Derived6' incorrectly extends base class static side 'typeof Base'. Property 'r' is protected in type 'typeof Derived6' but public in type 'typeof Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(53,7): error TS2417: Class static side 'typeof Derived7' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(52,7): error TS2417: Class static side 'typeof Derived7' incorrectly extends base class static side 'typeof Base'. Property 's' is protected in type 'typeof Derived7' but public in type 'typeof Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(58,7): error TS2417: Class static side 'typeof Derived8' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(57,7): error TS2417: Class static side 'typeof Derived8' incorrectly extends base class static side 'typeof Base'. Property 't' is protected in type 'typeof Derived8' but public in type 'typeof Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(63,7): error TS2417: Class static side 'typeof Derived9' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(62,7): error TS2417: Class static side 'typeof Derived9' incorrectly extends base class static side 'typeof Base'. Property 't' is protected in type 'typeof Derived9' but public in type 'typeof Base'. -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(68,7): error TS2417: Class static side 'typeof Derived10' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts(67,7): error TS2417: Class static side 'typeof Derived10' incorrectly extends base class static side 'typeof Base'. Property 'u' is protected in type 'typeof Derived10' but public in type 'typeof Base'. ==== tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassOverridesProtectedMembers3.ts (10 errors) ==== - var x: { foo: string; } var y: { foo: string; bar: string; } diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers3.js b/tests/baselines/reference/derivedClassOverridesProtectedMembers3.js index 615bdcddcf052..c1fcf54d66358 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers3.js +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers3.js @@ -1,5 +1,4 @@ //// [derivedClassOverridesProtectedMembers3.ts] - var x: { foo: string; } var y: { foo: string; bar: string; } diff --git a/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.errors.txt b/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.errors.txt index 60054fa47dcd0..06742e3e7204b 100644 --- a/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.errors.txt +++ b/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateInstanceShadowingProtectedInstance.ts(13,7): error TS2415: Class 'Derived' incorrectly extends base class 'Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateInstanceShadowingProtectedInstance.ts(12,7): error TS2415: Class 'Derived' incorrectly extends base class 'Base'. Property 'x' is private in type 'Derived' but not in type 'Base'. ==== tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateInstanceShadowingProtectedInstance.ts (1 errors) ==== - class Base { protected x: string; protected fn(): string { diff --git a/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.js b/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.js index 07cc9c4353942..c92a192a86416 100644 --- a/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.js +++ b/tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.js @@ -1,5 +1,4 @@ //// [derivedClassWithPrivateInstanceShadowingProtectedInstance.ts] - class Base { protected x: string; protected fn(): string { diff --git a/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.errors.txt b/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.errors.txt index 2697585cb20ee..2567c6e8ce0da 100644 --- a/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.errors.txt +++ b/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateStaticShadowingProtectedStatic.ts(13,7): error TS2417: Class static side 'typeof Derived' incorrectly extends base class static side 'typeof Base'. +tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateStaticShadowingProtectedStatic.ts(12,7): error TS2417: Class static side 'typeof Derived' incorrectly extends base class static side 'typeof Base'. Property 'x' is private in type 'typeof Derived' but not in type 'typeof Base'. ==== tests/cases/conformance/classes/members/inheritanceAndOverriding/derivedClassWithPrivateStaticShadowingProtectedStatic.ts (1 errors) ==== - class Base { protected static x: string; protected static fn(): string { diff --git a/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.js b/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.js index 52a50a8aa779d..e5310f6d837f4 100644 --- a/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.js +++ b/tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.js @@ -1,5 +1,4 @@ //// [derivedClassWithPrivateStaticShadowingProtectedStatic.ts] - class Base { protected static x: string; protected static fn(): string { diff --git a/tests/baselines/reference/destructureOptionalParameter.js b/tests/baselines/reference/destructureOptionalParameter.js index b937d58412f9a..18239bddc4e98 100644 --- a/tests/baselines/reference/destructureOptionalParameter.js +++ b/tests/baselines/reference/destructureOptionalParameter.js @@ -1,5 +1,4 @@ //// [destructureOptionalParameter.ts] - declare function f1({ a, b }?: { a: number, b: string }): void; function f2({ a, b }: { a: number, b: number } = { a: 0, b: 0 }) { diff --git a/tests/baselines/reference/destructureOptionalParameter.symbols b/tests/baselines/reference/destructureOptionalParameter.symbols index aa5252680cce8..d75722076a9f7 100644 --- a/tests/baselines/reference/destructureOptionalParameter.symbols +++ b/tests/baselines/reference/destructureOptionalParameter.symbols @@ -1,69 +1,68 @@ === tests/cases/compiler/destructureOptionalParameter.ts === - declare function f1({ a, b }?: { a: number, b: string }): void; >f1 : Symbol(f1, Decl(destructureOptionalParameter.ts, 0, 0)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 1, 21)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 1, 24)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 1, 32)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 1, 43)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 0, 21)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 0, 24)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 0, 32)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 0, 43)) function f2({ a, b }: { a: number, b: number } = { a: 0, b: 0 }) { ->f2 : Symbol(f2, Decl(destructureOptionalParameter.ts, 1, 63)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 3, 13)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 3, 16)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 3, 23)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 3, 34)) ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 3, 50)) ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 3, 56)) +>f2 : Symbol(f2, Decl(destructureOptionalParameter.ts, 0, 63)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 2, 13)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 2, 16)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 2, 23)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 2, 34)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 2, 50)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 2, 56)) a; ->a : Symbol(a, Decl(destructureOptionalParameter.ts, 3, 13)) +>a : Symbol(a, Decl(destructureOptionalParameter.ts, 2, 13)) b; ->b : Symbol(b, Decl(destructureOptionalParameter.ts, 3, 16)) +>b : Symbol(b, Decl(destructureOptionalParameter.ts, 2, 16)) } // Repro from #8681 interface Type { t: void } ->Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 6, 1)) ->t : Symbol(Type.t, Decl(destructureOptionalParameter.ts, 10, 16)) +>Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 5, 1)) +>t : Symbol(Type.t, Decl(destructureOptionalParameter.ts, 9, 16)) interface QueryMetadata { q: void } ->QueryMetadata : Symbol(QueryMetadata, Decl(destructureOptionalParameter.ts, 10, 26)) ->q : Symbol(QueryMetadata.q, Decl(destructureOptionalParameter.ts, 11, 25)) +>QueryMetadata : Symbol(QueryMetadata, Decl(destructureOptionalParameter.ts, 9, 26)) +>q : Symbol(QueryMetadata.q, Decl(destructureOptionalParameter.ts, 10, 25)) interface QueryMetadataFactory { ->QueryMetadataFactory : Symbol(QueryMetadataFactory, Decl(destructureOptionalParameter.ts, 11, 35)) +>QueryMetadataFactory : Symbol(QueryMetadataFactory, Decl(destructureOptionalParameter.ts, 10, 35)) (selector: Type | string, {descendants, read}?: { ->selector : Symbol(selector, Decl(destructureOptionalParameter.ts, 14, 5)) ->Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 6, 1)) ->descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 14, 31)) ->read : Symbol(read, Decl(destructureOptionalParameter.ts, 14, 43)) +>selector : Symbol(selector, Decl(destructureOptionalParameter.ts, 13, 5)) +>Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 5, 1)) +>descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 13, 31)) +>read : Symbol(read, Decl(destructureOptionalParameter.ts, 13, 43)) descendants?: boolean; ->descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 14, 53)) +>descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 13, 53)) read?: any; ->read : Symbol(read, Decl(destructureOptionalParameter.ts, 15, 30)) +>read : Symbol(read, Decl(destructureOptionalParameter.ts, 14, 30)) }): ParameterDecorator; >ParameterDecorator : Symbol(ParameterDecorator, Decl(lib.d.ts, --, --)) new (selector: Type | string, {descendants, read}?: { ->selector : Symbol(selector, Decl(destructureOptionalParameter.ts, 18, 9)) ->Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 6, 1)) ->descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 18, 35)) ->read : Symbol(read, Decl(destructureOptionalParameter.ts, 18, 47)) +>selector : Symbol(selector, Decl(destructureOptionalParameter.ts, 17, 9)) +>Type : Symbol(Type, Decl(destructureOptionalParameter.ts, 5, 1)) +>descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 17, 35)) +>read : Symbol(read, Decl(destructureOptionalParameter.ts, 17, 47)) descendants?: boolean; ->descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 18, 57)) +>descendants : Symbol(descendants, Decl(destructureOptionalParameter.ts, 17, 57)) read?: any; ->read : Symbol(read, Decl(destructureOptionalParameter.ts, 19, 30)) +>read : Symbol(read, Decl(destructureOptionalParameter.ts, 18, 30)) }): QueryMetadata; ->QueryMetadata : Symbol(QueryMetadata, Decl(destructureOptionalParameter.ts, 10, 26)) +>QueryMetadata : Symbol(QueryMetadata, Decl(destructureOptionalParameter.ts, 9, 26)) } diff --git a/tests/baselines/reference/destructureOptionalParameter.types b/tests/baselines/reference/destructureOptionalParameter.types index a72b03f59397f..f007a992c9e72 100644 --- a/tests/baselines/reference/destructureOptionalParameter.types +++ b/tests/baselines/reference/destructureOptionalParameter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/destructureOptionalParameter.ts === - declare function f1({ a, b }?: { a: number, b: string }): void; >f1 : ({a, b}?: { a: number; b: string; } | undefined) => void >a : number diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.errors.txt b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.errors.txt index beefbc9a85bc7..4dc6085e66274 100644 --- a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.errors.txt +++ b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(44,6): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(45,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(45,18): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(43,6): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(44,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts(44,18): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. ==== tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts (3 errors) ==== - /* AssignmentPattern: * ObjectAssignmentPattern * ArrayAssignmentPattern diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.js b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.js index d3a5c9ff5aae9..f6438ba8b655d 100644 --- a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.js +++ b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.js @@ -1,5 +1,4 @@ //// [destructuringArrayBindingPatternAndAssignment1ES6.ts] - /* AssignmentPattern: * ObjectAssignmentPattern * ArrayAssignmentPattern diff --git a/tests/baselines/reference/destructuringCatch.js b/tests/baselines/reference/destructuringCatch.js index 4593b22f1277d..8a10c01f6f8f2 100644 --- a/tests/baselines/reference/destructuringCatch.js +++ b/tests/baselines/reference/destructuringCatch.js @@ -1,5 +1,4 @@ //// [destructuringCatch.ts] - try { throw [0, 1]; } diff --git a/tests/baselines/reference/destructuringCatch.symbols b/tests/baselines/reference/destructuringCatch.symbols index 1d0a954b37776..a78beb8d776de 100644 --- a/tests/baselines/reference/destructuringCatch.symbols +++ b/tests/baselines/reference/destructuringCatch.symbols @@ -1,51 +1,50 @@ === tests/cases/conformance/es6/destructuring/destructuringCatch.ts === - try { throw [0, 1]; } catch ([a, b]) { ->a : Symbol(a, Decl(destructuringCatch.ts, 4, 8)) ->b : Symbol(b, Decl(destructuringCatch.ts, 4, 10)) +>a : Symbol(a, Decl(destructuringCatch.ts, 3, 8)) +>b : Symbol(b, Decl(destructuringCatch.ts, 3, 10)) a + b; ->a : Symbol(a, Decl(destructuringCatch.ts, 4, 8)) ->b : Symbol(b, Decl(destructuringCatch.ts, 4, 10)) +>a : Symbol(a, Decl(destructuringCatch.ts, 3, 8)) +>b : Symbol(b, Decl(destructuringCatch.ts, 3, 10)) } try { throw { a: 0, b: 1 }; ->a : Symbol(a, Decl(destructuringCatch.ts, 9, 11)) ->b : Symbol(b, Decl(destructuringCatch.ts, 9, 17)) +>a : Symbol(a, Decl(destructuringCatch.ts, 8, 11)) +>b : Symbol(b, Decl(destructuringCatch.ts, 8, 17)) } catch ({a, b}) { ->a : Symbol(a, Decl(destructuringCatch.ts, 11, 8)) ->b : Symbol(b, Decl(destructuringCatch.ts, 11, 10)) +>a : Symbol(a, Decl(destructuringCatch.ts, 10, 8)) +>b : Symbol(b, Decl(destructuringCatch.ts, 10, 10)) a + b; ->a : Symbol(a, Decl(destructuringCatch.ts, 11, 8)) ->b : Symbol(b, Decl(destructuringCatch.ts, 11, 10)) +>a : Symbol(a, Decl(destructuringCatch.ts, 10, 8)) +>b : Symbol(b, Decl(destructuringCatch.ts, 10, 10)) } try { throw [{ x: [0], z: 1 }]; ->x : Symbol(x, Decl(destructuringCatch.ts, 16, 12)) ->z : Symbol(z, Decl(destructuringCatch.ts, 16, 20)) +>x : Symbol(x, Decl(destructuringCatch.ts, 15, 12)) +>z : Symbol(z, Decl(destructuringCatch.ts, 15, 20)) } catch ([{x: [y], z}]) { >x : Symbol(x) ->y : Symbol(y, Decl(destructuringCatch.ts, 18, 13)) ->z : Symbol(z, Decl(destructuringCatch.ts, 18, 16)) +>y : Symbol(y, Decl(destructuringCatch.ts, 17, 13)) +>z : Symbol(z, Decl(destructuringCatch.ts, 17, 16)) y + z; ->y : Symbol(y, Decl(destructuringCatch.ts, 18, 13)) ->z : Symbol(z, Decl(destructuringCatch.ts, 18, 16)) +>y : Symbol(y, Decl(destructuringCatch.ts, 17, 13)) +>z : Symbol(z, Decl(destructuringCatch.ts, 17, 16)) } // Test of comment ranges. A fix to GH#11755 should update this. try { } catch (/*Test comment ranges*/[/*a*/a]) { ->a : Symbol(a, Decl(destructuringCatch.ts, 25, 31)) +>a : Symbol(a, Decl(destructuringCatch.ts, 24, 31)) } diff --git a/tests/baselines/reference/destructuringCatch.types b/tests/baselines/reference/destructuringCatch.types index 3f057e64e4ec3..c2a9b9f45c064 100644 --- a/tests/baselines/reference/destructuringCatch.types +++ b/tests/baselines/reference/destructuringCatch.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringCatch.ts === - try { throw [0, 1]; >[0, 1] : number[] diff --git a/tests/baselines/reference/destructuringInFunctionType.js b/tests/baselines/reference/destructuringInFunctionType.js index ac187f5b43db9..8490a14c91e19 100644 --- a/tests/baselines/reference/destructuringInFunctionType.js +++ b/tests/baselines/reference/destructuringInFunctionType.js @@ -1,5 +1,4 @@ //// [destructuringInFunctionType.ts] - interface a { a } interface b { b } interface c { c } diff --git a/tests/baselines/reference/destructuringInFunctionType.symbols b/tests/baselines/reference/destructuringInFunctionType.symbols index d73215a2ce60f..de4645753efc1 100644 --- a/tests/baselines/reference/destructuringInFunctionType.symbols +++ b/tests/baselines/reference/destructuringInFunctionType.symbols @@ -1,78 +1,77 @@ === tests/cases/conformance/es6/destructuring/destructuringInFunctionType.ts === - interface a { a } >a : Symbol(a, Decl(destructuringInFunctionType.ts, 0, 0)) ->a : Symbol(a.a, Decl(destructuringInFunctionType.ts, 1, 13)) +>a : Symbol(a.a, Decl(destructuringInFunctionType.ts, 0, 13)) interface b { b } ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 1, 17)) ->b : Symbol(b.b, Decl(destructuringInFunctionType.ts, 2, 13)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 0, 17)) +>b : Symbol(b.b, Decl(destructuringInFunctionType.ts, 1, 13)) interface c { c } ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 2, 17)) ->c : Symbol(c.c, Decl(destructuringInFunctionType.ts, 3, 13)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 1, 17)) +>c : Symbol(c.c, Decl(destructuringInFunctionType.ts, 2, 13)) type T1 = ([a, b, c]); ->T1 : Symbol(T1, Decl(destructuringInFunctionType.ts, 3, 17)) +>T1 : Symbol(T1, Decl(destructuringInFunctionType.ts, 2, 17)) >a : Symbol(a, Decl(destructuringInFunctionType.ts, 0, 0)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 1, 17)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 2, 17)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 0, 17)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 1, 17)) type F1 = ([a, b, c]) => void; ->F1 : Symbol(F1, Decl(destructuringInFunctionType.ts, 5, 22)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 6, 12)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 6, 14)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 6, 17)) +>F1 : Symbol(F1, Decl(destructuringInFunctionType.ts, 4, 22)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 5, 12)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 5, 14)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 5, 17)) type T2 = ({ a }); ->T2 : Symbol(T2, Decl(destructuringInFunctionType.ts, 6, 30)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 8, 12)) +>T2 : Symbol(T2, Decl(destructuringInFunctionType.ts, 5, 30)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 7, 12)) type F2 = ({ a }) => void; ->F2 : Symbol(F2, Decl(destructuringInFunctionType.ts, 8, 18)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 9, 12)) +>F2 : Symbol(F2, Decl(destructuringInFunctionType.ts, 7, 18)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 8, 12)) type T3 = ([{ a: b }, { b: a }]); ->T3 : Symbol(T3, Decl(destructuringInFunctionType.ts, 9, 26)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 11, 13)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 1, 17)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 11, 23)) +>T3 : Symbol(T3, Decl(destructuringInFunctionType.ts, 8, 26)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 10, 13)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 0, 17)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 10, 23)) >a : Symbol(a, Decl(destructuringInFunctionType.ts, 0, 0)) type F3 = ([{ a: b }, { b: a }]) => void; ->F3 : Symbol(F3, Decl(destructuringInFunctionType.ts, 11, 33)) +>F3 : Symbol(F3, Decl(destructuringInFunctionType.ts, 10, 33)) >a : Symbol(a) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 12, 13)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 11, 13)) >b : Symbol(b) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 12, 23)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 11, 23)) type T4 = ([{ a: [b, c] }]); ->T4 : Symbol(T4, Decl(destructuringInFunctionType.ts, 12, 41)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 14, 13)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 1, 17)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 2, 17)) +>T4 : Symbol(T4, Decl(destructuringInFunctionType.ts, 11, 41)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 13, 13)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 0, 17)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 1, 17)) type F4 = ([{ a: [b, c] }]) => void; ->F4 : Symbol(F4, Decl(destructuringInFunctionType.ts, 14, 28)) +>F4 : Symbol(F4, Decl(destructuringInFunctionType.ts, 13, 28)) >a : Symbol(a) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 15, 18)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 15, 20)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 14, 18)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 14, 20)) type C1 = new ([{ a: [b, c] }]) => void; ->C1 : Symbol(C1, Decl(destructuringInFunctionType.ts, 15, 36)) +>C1 : Symbol(C1, Decl(destructuringInFunctionType.ts, 14, 36)) >a : Symbol(a) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 17, 22)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 17, 24)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 16, 22)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 16, 24)) var v1 = ([a, b, c]) => "hello"; ->v1 : Symbol(v1, Decl(destructuringInFunctionType.ts, 19, 3)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 19, 11)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 19, 13)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 19, 16)) +>v1 : Symbol(v1, Decl(destructuringInFunctionType.ts, 18, 3)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 18, 11)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 18, 13)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 18, 16)) var v2: ([a, b, c]) => string; ->v2 : Symbol(v2, Decl(destructuringInFunctionType.ts, 20, 3)) ->a : Symbol(a, Decl(destructuringInFunctionType.ts, 20, 10)) ->b : Symbol(b, Decl(destructuringInFunctionType.ts, 20, 12)) ->c : Symbol(c, Decl(destructuringInFunctionType.ts, 20, 15)) +>v2 : Symbol(v2, Decl(destructuringInFunctionType.ts, 19, 3)) +>a : Symbol(a, Decl(destructuringInFunctionType.ts, 19, 10)) +>b : Symbol(b, Decl(destructuringInFunctionType.ts, 19, 12)) +>c : Symbol(c, Decl(destructuringInFunctionType.ts, 19, 15)) diff --git a/tests/baselines/reference/destructuringInFunctionType.types b/tests/baselines/reference/destructuringInFunctionType.types index 3f635d44568d6..09887f5d45a73 100644 --- a/tests/baselines/reference/destructuringInFunctionType.types +++ b/tests/baselines/reference/destructuringInFunctionType.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringInFunctionType.ts === - interface a { a } >a : a >a : any diff --git a/tests/baselines/reference/destructuringInVariableDeclarations1.js b/tests/baselines/reference/destructuringInVariableDeclarations1.js index a7645ceabe9ea..0cad8e5b9900e 100644 --- a/tests/baselines/reference/destructuringInVariableDeclarations1.js +++ b/tests/baselines/reference/destructuringInVariableDeclarations1.js @@ -8,7 +8,7 @@ export let { toString } = 1; //// [destructuringInVariableDeclarations1.js] "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -exports.toString = (1).toString; +exports.toString = 1..toString; { let { toFixed } = 1; } diff --git a/tests/baselines/reference/destructuringInVariableDeclarations3.js b/tests/baselines/reference/destructuringInVariableDeclarations3.js index 2522a704e180a..18708c92a7d0d 100644 --- a/tests/baselines/reference/destructuringInVariableDeclarations3.js +++ b/tests/baselines/reference/destructuringInVariableDeclarations3.js @@ -9,7 +9,7 @@ export let { toString } = 1; define(["require", "exports"], function (require, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); - exports.toString = (1).toString; + exports.toString = 1..toString; { let { toFixed } = 1; } diff --git a/tests/baselines/reference/destructuringInVariableDeclarations5.js b/tests/baselines/reference/destructuringInVariableDeclarations5.js index 20a094a03750d..5aa76cc3a9293 100644 --- a/tests/baselines/reference/destructuringInVariableDeclarations5.js +++ b/tests/baselines/reference/destructuringInVariableDeclarations5.js @@ -17,7 +17,7 @@ export let { toString } = 1; })(function (require, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); - exports.toString = (1).toString; + exports.toString = 1..toString; { let { toFixed } = 1; } diff --git a/tests/baselines/reference/destructuringInVariableDeclarations7.js b/tests/baselines/reference/destructuringInVariableDeclarations7.js index e7e4f803b7758..82f28b096727d 100644 --- a/tests/baselines/reference/destructuringInVariableDeclarations7.js +++ b/tests/baselines/reference/destructuringInVariableDeclarations7.js @@ -13,7 +13,7 @@ System.register([], function (exports_1, context_1) { return { setters: [], execute: function () { - exports_1("toString", toString = (1).toString); + exports_1("toString", toString = 1..toString); { let { toFixed } = 1; } diff --git a/tests/baselines/reference/destructuringInVariableDeclarations8.js b/tests/baselines/reference/destructuringInVariableDeclarations8.js index 12340433bf4e0..bf4be279e78db 100644 --- a/tests/baselines/reference/destructuringInVariableDeclarations8.js +++ b/tests/baselines/reference/destructuringInVariableDeclarations8.js @@ -14,7 +14,7 @@ System.register([], function (exports_1, context_1) { return { setters: [], execute: function () { - toString = (1).toString; + toString = 1..toString; { let { toFixed } = 1; } diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.js b/tests/baselines/reference/destructuringParameterDeclaration3ES5.js index 5dea671ee1a73..08dfa25a4d42e 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.js +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration3ES5.ts] - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols index b9bf9ee54e29f..93faef8af6415 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. @@ -12,134 +11,134 @@ type arrayString = Array >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) type someArray = Array | number[]; ->someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32)) +>someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 6, 32)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) type stringOrNumArray = Array; ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 42)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) function a1(...x: (number|string)[]) { } ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 9, 45)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 11, 12)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 8, 45)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 10, 12)) function a2(...a) { } ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5.ts, 11, 40)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 12, 12)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5.ts, 10, 40)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 11, 12)) function a3(...a: Array) { } ->a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12)) +>a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 11, 21)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 12, 12)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) function a4(...a: arrayString) { } ->a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 14, 12)) +>a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 12, 36)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12)) >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0)) function a5(...a: stringOrNumArray) { } ->a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES5.ts, 14, 34)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 15, 12)) ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42)) +>a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES5.ts, 13, 34)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 14, 12)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 42)) function a9([a, b, [[c]]]) { } ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5.ts, 15, 39)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 16, 13)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 16, 15)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 16, 21)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5.ts, 14, 39)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 15, 13)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 15, 15)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 15, 21)) function a10([a, b, [[c]], ...x]) { } ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 16, 30)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 17, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 17, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 17, 22)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 17, 26)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 15, 30)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 16, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 16, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 16, 22)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 16, 26)) function a11([a, b, c, ...x]: number[]) { } ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5.ts, 17, 37)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 18, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 18, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 18, 19)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 18, 22)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5.ts, 16, 37)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 17, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5.ts, 17, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5.ts, 17, 19)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5.ts, 17, 22)) var array = [1, 2, 3]; ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 21, 3)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 20, 3)) var array2 = [true, false, "hello"]; ->array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES5.ts, 22, 3)) +>array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES5.ts, 21, 3)) a2([...array]); ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5.ts, 11, 40)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 21, 3)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5.ts, 10, 40)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 20, 3)) a1(...array); ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 9, 45)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 21, 3)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 8, 45)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5.ts, 20, 3)) a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5.ts, 15, 39)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5.ts, 14, 39)) a10([1, 2, [["string"]], false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 15, 30)) a10([1, 2, 3, false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 15, 30)) a10([1, 2]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5.ts, 15, 30)) a11([1, 2]); // Parameter type is number[] ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5.ts, 17, 37)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5.ts, 16, 37)) // Rest parameter with generic function foo(...a: T[]) { } ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 31, 12)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 34, 13)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 34, 16)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 34, 13)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 30, 12)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 33, 13)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 33, 16)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 33, 13)) foo("hello", 1, 2); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 30, 12)) foo("hello", "world"); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5.ts, 30, 12)) enum E { a, b } ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 8)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 38, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 37, 8)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 37, 11)) const enum E1 { a, b } ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 39, 15)) ->b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES5.ts, 39, 18)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) +>b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES5.ts, 38, 18)) function foo1(...a: T[]) { } ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 39, 22)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 40, 14)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 22)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 39, 14)) >Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 40, 32)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 40, 14)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 39, 32)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 39, 14)) foo1(1, 2, 3, E.a); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 39, 22)) ->E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 8)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 8)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 22)) +>E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 37, 8)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5.ts, 37, 8)) foo1(1, 2, 3, E1.a, E.b); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 39, 22)) ->E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 39, 15)) ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 39, 15)) ->E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 38, 11)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 36, 22)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 38, 11)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 22)) +>E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5.ts, 38, 15)) +>E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 37, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5.ts, 35, 22)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5.ts, 37, 11)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.types b/tests/baselines/reference/destructuringParameterDeclaration3ES5.types index 7d4662100ed8f..a91d54d528432 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.types +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js index ab00e874e3e63..087bf87aaea25 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration3ES5iterable.ts] - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols index 52b2d290fa08f..8ce990518011f 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5iterable.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. @@ -12,134 +11,134 @@ type arrayString = Array >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type someArray = Array | number[]; ->someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 7, 32)) +>someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 6, 32)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type stringOrNumArray = Array; ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 42)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 7, 42)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function a1(...x: (number|string)[]) { } ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 9, 45)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 12)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 45)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 10, 12)) function a2(...a) { } ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 40)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 12)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 10, 40)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 12)) function a3(...a: Array) { } ->a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 21)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 12)) +>a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 21)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 12)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function a4(...a: arrayString) { } ->a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 36)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 12)) +>a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 36)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 12)) >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5iterable.ts, 0, 0)) function a5(...a: stringOrNumArray) { } ->a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 34)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 12)) ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 42)) +>a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 34)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 12)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 7, 42)) function a9([a, b, [[c]]]) { } ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 39)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 13)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 15)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 21)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 39)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 13)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 15)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 21)) function a10([a, b, [[c]], ...x]) { } ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 22)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 26)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 30)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 22)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 26)) function a11([a, b, c, ...x]: number[]) { } ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 37)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 19)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 22)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 37)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 19)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 22)) var array = [1, 2, 3]; ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 20, 3)) var array2 = [true, false, "hello"]; ->array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 22, 3)) +>array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) a2([...array]); ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 40)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 10, 40)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 20, 3)) a1(...array); ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 9, 45)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 45)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 20, 3)) a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 39)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 39)) a10([1, 2, [["string"]], false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 30)) a10([1, 2, 3, false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 30)) a10([1, 2]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 30)) a11([1, 2]); // Parameter type is number[] ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 37)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 37)) // Rest parameter with generic function foo(...a: T[]) { } ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 31, 12)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 34, 13)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 34, 16)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 34, 13)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 30, 12)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 33, 13)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 33, 16)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 33, 13)) foo("hello", 1, 2); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 30, 12)) foo("hello", "world"); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 30, 12)) enum E { a, b } ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 8)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 8)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 11)) const enum E1 { a, b } ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 15)) ->b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 18)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) +>b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 18)) function foo1(...a: T[]) { } ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 22)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 40, 14)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 22)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 14)) >Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 40, 32)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 40, 14)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 32)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 14)) foo1(1, 2, 3, E.a); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 22)) ->E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 8)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 8)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 22)) +>E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 8)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 8)) foo1(1, 2, 3, E1.a, E.b); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 22)) ->E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 15)) ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 15)) ->E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 11)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 36, 22)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 11)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 22)) +>E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) +>E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 35, 22)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 37, 11)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types index d003531c67b72..5f2963abe8781 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5iterable.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.js b/tests/baselines/reference/destructuringParameterDeclaration3ES6.js index 5893168bf9335..2857cb2276be9 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.js +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration3ES6.ts] - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols index e372d6d02a388..6d205bdde8869 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES6.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. @@ -12,134 +11,134 @@ type arrayString = Array >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) type someArray = Array | number[]; ->someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32)) +>someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 6, 32)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) type stringOrNumArray = Array; ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 42)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) function a1(...x: (number|string)[]) { } ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 9, 45)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 11, 12)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 8, 45)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 10, 12)) function a2(...a) { } ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES6.ts, 11, 40)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 12, 12)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES6.ts, 10, 40)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 11, 12)) function a3(...a: Array) { } ->a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12)) +>a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 11, 21)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 12, 12)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) function a4(...a: arrayString) { } ->a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 14, 12)) +>a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 12, 36)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12)) >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0)) function a5(...a: stringOrNumArray) { } ->a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES6.ts, 14, 34)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 15, 12)) ->stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42)) +>a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES6.ts, 13, 34)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 14, 12)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 42)) function a9([a, b, [[c]]]) { } ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES6.ts, 15, 39)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 16, 13)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 16, 15)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 16, 21)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES6.ts, 14, 39)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 15, 13)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 15, 15)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 15, 21)) function a10([a, b, [[c]], ...x]) { } ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 16, 30)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 17, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 17, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 17, 22)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 17, 26)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 15, 30)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 16, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 16, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 16, 22)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 16, 26)) function a11([a, b, c, ...x]: number[]) { } ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES6.ts, 17, 37)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 18, 14)) ->b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 18, 16)) ->c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 18, 19)) ->x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 18, 22)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES6.ts, 16, 37)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 17, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES6.ts, 17, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES6.ts, 17, 19)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES6.ts, 17, 22)) var array = [1, 2, 3]; ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 21, 3)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 20, 3)) var array2 = [true, false, "hello"]; ->array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES6.ts, 22, 3)) +>array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES6.ts, 21, 3)) a2([...array]); ->a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES6.ts, 11, 40)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 21, 3)) +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES6.ts, 10, 40)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 20, 3)) a1(...array); ->a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 9, 45)) ->array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 21, 3)) +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 8, 45)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES6.ts, 20, 3)) a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] ->a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES6.ts, 15, 39)) +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES6.ts, 14, 39)) a10([1, 2, [["string"]], false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 15, 30)) a10([1, 2, 3, false, true]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 15, 30)) a10([1, 2]); // Parameter type is any[] ->a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 16, 30)) +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES6.ts, 15, 30)) a11([1, 2]); // Parameter type is number[] ->a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES6.ts, 17, 37)) +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES6.ts, 16, 37)) // Rest parameter with generic function foo(...a: T[]) { } ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 31, 12)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 34, 13)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 34, 16)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 34, 13)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 30, 12)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 33, 13)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 33, 16)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 33, 13)) foo("hello", 1, 2); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 30, 12)) foo("hello", "world"); ->foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 31, 12)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES6.ts, 30, 12)) enum E { a, b } ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 8)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 38, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 37, 8)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 37, 11)) const enum E1 { a, b } ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 39, 15)) ->b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES6.ts, 39, 18)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES6.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) +>b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES6.ts, 38, 18)) function foo1(...a: T[]) { } ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 39, 22)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 40, 14)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 22)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 39, 14)) >Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 40, 32)) ->T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 40, 14)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 39, 32)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 39, 14)) foo1(1, 2, 3, E.a); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 39, 22)) ->E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 8)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 36, 22)) ->a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 8)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 22)) +>E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 37, 8)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 35, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES6.ts, 37, 8)) foo1(1, 2, 3, E1.a, E.b); ->foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 39, 22)) ->E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 39, 15)) ->E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) ->a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 39, 15)) ->E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 38, 11)) ->E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 36, 22)) ->b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 38, 11)) +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 22)) +>E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES6.ts, 37, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES6.ts, 38, 15)) +>E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 37, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES6.ts, 35, 22)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES6.ts, 37, 11)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.types b/tests/baselines/reference/destructuringParameterDeclaration3ES6.types index 8ec0a27850ba5..397ec934a2f58 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.types +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES6.ts === - // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5.js b/tests/baselines/reference/destructuringParameterDeclaration7ES5.js index f9dac1ae2fabe..30ec04d2a6657 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5.js +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration7ES5.ts] - interface ISomething { foo: string, bar: string diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration7ES5.symbols index 44709f18e1b2b..a2a43a916057c 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5.symbols @@ -1,33 +1,32 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5.ts === - interface ISomething { >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5.ts, 0, 0)) foo: string, ->foo : Symbol(ISomething.foo, Decl(destructuringParameterDeclaration7ES5.ts, 1, 22)) +>foo : Symbol(ISomething.foo, Decl(destructuringParameterDeclaration7ES5.ts, 0, 22)) bar: string ->bar : Symbol(ISomething.bar, Decl(destructuringParameterDeclaration7ES5.ts, 2, 16)) +>bar : Symbol(ISomething.bar, Decl(destructuringParameterDeclaration7ES5.ts, 1, 16)) } function foo({}, {foo, bar}: ISomething) {} ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 4, 1)) ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 6, 18)) ->bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5.ts, 6, 22)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 3, 1)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 5, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5.ts, 5, 22)) >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5.ts, 0, 0)) function baz([], {foo, bar}: ISomething) {} ->baz : Symbol(baz, Decl(destructuringParameterDeclaration7ES5.ts, 6, 43)) ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 8, 18)) ->bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5.ts, 8, 22)) +>baz : Symbol(baz, Decl(destructuringParameterDeclaration7ES5.ts, 5, 43)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5.ts, 7, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5.ts, 7, 22)) >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5.ts, 0, 0)) function one([], {}) {} ->one : Symbol(one, Decl(destructuringParameterDeclaration7ES5.ts, 8, 43)) +>one : Symbol(one, Decl(destructuringParameterDeclaration7ES5.ts, 7, 43)) function two([], [a, b, c]: number[]) {} ->two : Symbol(two, Decl(destructuringParameterDeclaration7ES5.ts, 10, 23)) ->a : Symbol(a, Decl(destructuringParameterDeclaration7ES5.ts, 12, 18)) ->b : Symbol(b, Decl(destructuringParameterDeclaration7ES5.ts, 12, 20)) ->c : Symbol(c, Decl(destructuringParameterDeclaration7ES5.ts, 12, 23)) +>two : Symbol(two, Decl(destructuringParameterDeclaration7ES5.ts, 9, 23)) +>a : Symbol(a, Decl(destructuringParameterDeclaration7ES5.ts, 11, 18)) +>b : Symbol(b, Decl(destructuringParameterDeclaration7ES5.ts, 11, 20)) +>c : Symbol(c, Decl(destructuringParameterDeclaration7ES5.ts, 11, 23)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5.types b/tests/baselines/reference/destructuringParameterDeclaration7ES5.types index 7d64383b0b668..502a176596aa2 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5.types +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5.ts === - interface ISomething { >ISomething : ISomething diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js index 818ea428c1d29..5a357aaef6445 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js @@ -1,5 +1,4 @@ //// [destructuringParameterDeclaration7ES5iterable.ts] - interface ISomething { foo: string, bar: string diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols index 0548f1247f6d3..daa49cfe15249 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols @@ -1,33 +1,32 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5iterable.ts === - interface ISomething { >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 0)) foo: string, ->foo : Symbol(ISomething.foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 1, 22)) +>foo : Symbol(ISomething.foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 22)) bar: string ->bar : Symbol(ISomething.bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 2, 16)) +>bar : Symbol(ISomething.bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 1, 16)) } function foo({}, {foo, bar}: ISomething) {} ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 4, 1)) ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 6, 18)) ->bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 6, 22)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 3, 1)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 5, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 5, 22)) >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 0)) function baz([], {foo, bar}: ISomething) {} ->baz : Symbol(baz, Decl(destructuringParameterDeclaration7ES5iterable.ts, 6, 43)) ->foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 8, 18)) ->bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 8, 22)) +>baz : Symbol(baz, Decl(destructuringParameterDeclaration7ES5iterable.ts, 5, 43)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 7, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 7, 22)) >ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 0)) function one([], {}) {} ->one : Symbol(one, Decl(destructuringParameterDeclaration7ES5iterable.ts, 8, 43)) +>one : Symbol(one, Decl(destructuringParameterDeclaration7ES5iterable.ts, 7, 43)) function two([], [a, b, c]: number[]) {} ->two : Symbol(two, Decl(destructuringParameterDeclaration7ES5iterable.ts, 10, 23)) ->a : Symbol(a, Decl(destructuringParameterDeclaration7ES5iterable.ts, 12, 18)) ->b : Symbol(b, Decl(destructuringParameterDeclaration7ES5iterable.ts, 12, 20)) ->c : Symbol(c, Decl(destructuringParameterDeclaration7ES5iterable.ts, 12, 23)) +>two : Symbol(two, Decl(destructuringParameterDeclaration7ES5iterable.ts, 9, 23)) +>a : Symbol(a, Decl(destructuringParameterDeclaration7ES5iterable.ts, 11, 18)) +>b : Symbol(b, Decl(destructuringParameterDeclaration7ES5iterable.ts, 11, 20)) +>c : Symbol(c, Decl(destructuringParameterDeclaration7ES5iterable.ts, 11, 23)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types index 402ea7ac5e161..542407cabe265 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5iterable.ts === - interface ISomething { >ISomething : ISomething diff --git a/tests/baselines/reference/destructuringParameterProperties4.errors.txt b/tests/baselines/reference/destructuringParameterProperties4.errors.txt index 249cecbc74f63..6e995baa99648 100644 --- a/tests/baselines/reference/destructuringParameterProperties4.errors.txt +++ b/tests/baselines/reference/destructuringParameterProperties4.errors.txt @@ -1,17 +1,16 @@ -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(3,31): error TS1187: A parameter property may not be declared using a binding pattern. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(4,59): error TS2339: Property 'b' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(4,83): error TS2339: Property 'c' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(5,18): error TS2339: Property 'a' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(10,21): error TS2339: Property 'a' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(14,21): error TS2339: Property 'b' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(18,21): error TS2339: Property 'c' does not exist on type 'C1'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(24,24): error TS2339: Property 'a' does not exist on type 'C2'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(24,34): error TS2339: Property 'b' does not exist on type 'C2'. -tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(24,44): error TS2339: Property 'c' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(2,31): error TS1187: A parameter property may not be declared using a binding pattern. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(3,59): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(3,83): error TS2339: Property 'c' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(4,18): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(9,21): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(13,21): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(17,21): error TS2339: Property 'c' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(23,24): error TS2339: Property 'a' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(23,34): error TS2339: Property 'b' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(23,44): error TS2339: Property 'c' does not exist on type 'C2'. ==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts (10 errors) ==== - class C1 { constructor(private k: T, protected [a, b, c]: [T,U,V]) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/tests/baselines/reference/destructuringParameterProperties4.js b/tests/baselines/reference/destructuringParameterProperties4.js index aa8087cfde68c..33c906f51b53d 100644 --- a/tests/baselines/reference/destructuringParameterProperties4.js +++ b/tests/baselines/reference/destructuringParameterProperties4.js @@ -1,5 +1,4 @@ //// [destructuringParameterProperties4.ts] - class C1 { constructor(private k: T, protected [a, b, c]: [T,U,V]) { if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { diff --git a/tests/baselines/reference/destructuringTypeAssertionsES5_5.js b/tests/baselines/reference/destructuringTypeAssertionsES5_5.js index a51ac02af777b..dddfaee8527b2 100644 --- a/tests/baselines/reference/destructuringTypeAssertionsES5_5.js +++ b/tests/baselines/reference/destructuringTypeAssertionsES5_5.js @@ -2,4 +2,4 @@ var { x } = 0; //// [destructuringTypeAssertionsES5_5.js] -var x = (0).x; +var x = 0..x; diff --git a/tests/baselines/reference/destructuringWithNumberLiteral.js b/tests/baselines/reference/destructuringWithNumberLiteral.js index 8804b850cc39a..e8a5ee7d45e23 100644 --- a/tests/baselines/reference/destructuringWithNumberLiteral.js +++ b/tests/baselines/reference/destructuringWithNumberLiteral.js @@ -2,4 +2,4 @@ var { toExponential } = 0; //// [destructuringWithNumberLiteral.js] -var toExponential = (0).toExponential; +var toExponential = 0..toExponential; diff --git a/tests/baselines/reference/discriminantPropertyCheck.errors.txt b/tests/baselines/reference/discriminantPropertyCheck.errors.txt index 41593c4b2245d..33bdb6ea731ac 100644 --- a/tests/baselines/reference/discriminantPropertyCheck.errors.txt +++ b/tests/baselines/reference/discriminantPropertyCheck.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/discriminantPropertyCheck.ts(30,9): error TS2532: Object is possibly 'undefined'. -tests/cases/compiler/discriminantPropertyCheck.ts(66,9): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/discriminantPropertyCheck.ts(29,9): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/discriminantPropertyCheck.ts(65,9): error TS2532: Object is possibly 'undefined'. ==== tests/cases/compiler/discriminantPropertyCheck.ts (2 errors) ==== - type Item = Item1 | Item2; interface Base { diff --git a/tests/baselines/reference/discriminantPropertyCheck.js b/tests/baselines/reference/discriminantPropertyCheck.js index b75a6277735f7..b946fe520494d 100644 --- a/tests/baselines/reference/discriminantPropertyCheck.js +++ b/tests/baselines/reference/discriminantPropertyCheck.js @@ -1,5 +1,4 @@ //// [discriminantPropertyCheck.ts] - type Item = Item1 | Item2; interface Base { diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.js b/tests/baselines/reference/discriminantsAndNullOrUndefined.js index 153950f8ab5d9..20704edad6ca6 100644 --- a/tests/baselines/reference/discriminantsAndNullOrUndefined.js +++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.js @@ -1,5 +1,4 @@ //// [discriminantsAndNullOrUndefined.ts] - // Repro from #10228 interface A { kind: 'A'; } diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols b/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols index 3f95fcf3a3fef..01fd35e1a744a 100644 --- a/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols +++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols @@ -1,61 +1,60 @@ === tests/cases/compiler/discriminantsAndNullOrUndefined.ts === - // Repro from #10228 interface A { kind: 'A'; } >A : Symbol(A, Decl(discriminantsAndNullOrUndefined.ts, 0, 0)) ->kind : Symbol(A.kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13)) +>kind : Symbol(A.kind, Decl(discriminantsAndNullOrUndefined.ts, 2, 13)) interface B { kind: 'B'; } ->B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) ->kind : Symbol(B.kind, Decl(discriminantsAndNullOrUndefined.ts, 4, 13)) +>B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 2, 26)) +>kind : Symbol(B.kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13)) type C = A | B | undefined; ->C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 4, 26)) +>C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) >A : Symbol(A, Decl(discriminantsAndNullOrUndefined.ts, 0, 0)) ->B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) +>B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 2, 26)) function never(_: never): never { ->never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 6, 27)) ->_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 8, 15)) +>never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 5, 27)) +>_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 7, 15)) throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function useA(_: A): void { } ->useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 10, 1)) ->_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 12, 14)) +>useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 9, 1)) +>_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 11, 14)) >A : Symbol(A, Decl(discriminantsAndNullOrUndefined.ts, 0, 0)) function useB(_: B): void { } ->useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 12, 29)) ->_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 13, 14)) ->B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) +>useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 11, 29)) +>_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 12, 14)) +>B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 2, 26)) declare var c: C; ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) ->C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 4, 26)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) +>C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 3, 26)) if (c !== undefined) { ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) >undefined : Symbol(undefined) switch (c.kind) { ->c.kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13), Decl(discriminantsAndNullOrUndefined.ts, 4, 13)) ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) ->kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13), Decl(discriminantsAndNullOrUndefined.ts, 4, 13)) +>c.kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 2, 13), Decl(discriminantsAndNullOrUndefined.ts, 3, 13)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) +>kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 2, 13), Decl(discriminantsAndNullOrUndefined.ts, 3, 13)) case 'A': useA(c); break; ->useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 10, 1)) ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) +>useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 9, 1)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) case 'B': useB(c); break; ->useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 12, 29)) ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) +>useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 11, 29)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) default: never(c); ->never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 6, 27)) ->c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11)) +>never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 5, 27)) +>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 14, 11)) } } diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.types b/tests/baselines/reference/discriminantsAndNullOrUndefined.types index 7a2918ab83b42..fbcdc4883338d 100644 --- a/tests/baselines/reference/discriminantsAndNullOrUndefined.types +++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.types @@ -1,5 +1,4 @@ === tests/cases/compiler/discriminantsAndNullOrUndefined.ts === - // Repro from #10228 interface A { kind: 'A'; } diff --git a/tests/baselines/reference/discriminantsAndPrimitives.js b/tests/baselines/reference/discriminantsAndPrimitives.js index 1d11781a70784..d72ac0ff9f974 100644 --- a/tests/baselines/reference/discriminantsAndPrimitives.js +++ b/tests/baselines/reference/discriminantsAndPrimitives.js @@ -1,5 +1,4 @@ //// [discriminantsAndPrimitives.ts] - // Repro from #10257 plus other tests interface Foo { diff --git a/tests/baselines/reference/discriminantsAndPrimitives.symbols b/tests/baselines/reference/discriminantsAndPrimitives.symbols index c84f32cd99073..818fbc663fff9 100644 --- a/tests/baselines/reference/discriminantsAndPrimitives.symbols +++ b/tests/baselines/reference/discriminantsAndPrimitives.symbols @@ -1,117 +1,116 @@ === tests/cases/compiler/discriminantsAndPrimitives.ts === - // Repro from #10257 plus other tests interface Foo { >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) kind: "foo"; ->kind : Symbol(Foo.kind, Decl(discriminantsAndPrimitives.ts, 3, 15)) +>kind : Symbol(Foo.kind, Decl(discriminantsAndPrimitives.ts, 2, 15)) name: string; ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } interface Bar { ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) kind: "bar"; ->kind : Symbol(Bar.kind, Decl(discriminantsAndPrimitives.ts, 8, 15)) +>kind : Symbol(Bar.kind, Decl(discriminantsAndPrimitives.ts, 7, 15)) length: string; ->length : Symbol(Bar.length, Decl(discriminantsAndPrimitives.ts, 9, 16)) +>length : Symbol(Bar.length, Decl(discriminantsAndPrimitives.ts, 8, 16)) } function f1(x: Foo | Bar | string) { ->f1 : Symbol(f1, Decl(discriminantsAndPrimitives.ts, 11, 1)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12)) +>f1 : Symbol(f1, Decl(discriminantsAndPrimitives.ts, 10, 1)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 12, 12)) >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) if (typeof x !== 'string') { ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 12, 12)) switch(x.kind) { ->x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12)) ->kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) +>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 12, 12)) +>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) case 'foo': x.name; ->x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12)) ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 12, 12)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } } } function f2(x: Foo | Bar | string | undefined) { ->f2 : Symbol(f2, Decl(discriminantsAndPrimitives.ts, 20, 1)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12)) +>f2 : Symbol(f2, Decl(discriminantsAndPrimitives.ts, 19, 1)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 21, 12)) >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) if (typeof x === "object") { ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 21, 12)) switch(x.kind) { ->x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12)) ->kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) +>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 21, 12)) +>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) case 'foo': x.name; ->x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12)) ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 21, 12)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } } } function f3(x: Foo | Bar | string | null) { ->f3 : Symbol(f3, Decl(discriminantsAndPrimitives.ts, 29, 1)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) +>f3 : Symbol(f3, Decl(discriminantsAndPrimitives.ts, 28, 1)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) if (x && typeof x !== "string") { ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) switch(x.kind) { ->x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) ->kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) +>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) +>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) case 'foo': x.name; ->x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12)) ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 30, 12)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } } } function f4(x: Foo | Bar | string | number | null) { ->f4 : Symbol(f4, Decl(discriminantsAndPrimitives.ts, 38, 1)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) +>f4 : Symbol(f4, Decl(discriminantsAndPrimitives.ts, 37, 1)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) >Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0)) ->Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1)) +>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 5, 1)) if (x && typeof x === "object") { ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) switch(x.kind) { ->x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) ->kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15)) +>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) +>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 2, 15), Decl(discriminantsAndPrimitives.ts, 7, 15)) case 'foo': x.name; ->x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) ->x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12)) ->name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16)) +>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) +>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 39, 12)) +>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 3, 16)) } } } diff --git a/tests/baselines/reference/discriminantsAndPrimitives.types b/tests/baselines/reference/discriminantsAndPrimitives.types index 0870d17948fce..a4efa40198705 100644 --- a/tests/baselines/reference/discriminantsAndPrimitives.types +++ b/tests/baselines/reference/discriminantsAndPrimitives.types @@ -1,5 +1,4 @@ === tests/cases/compiler/discriminantsAndPrimitives.ts === - // Repro from #10257 plus other tests interface Foo { diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.js b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.js index cddfb7aecdc94..a18eac74cdbcf 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.js +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.js @@ -1,5 +1,4 @@ //// [file1.ts] - class C { /*! remove pinned comment anywhere else */ public foo(x: string, y: any) diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.symbols b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.symbols index bd6f35e406f3c..cdf2719546e55 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.symbols +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.symbols @@ -1,24 +1,23 @@ === tests/cases/compiler/file1.ts === - class C { >C : Symbol(C, Decl(file1.ts, 0, 0)) /*! remove pinned comment anywhere else */ public foo(x: string, y: any) ->foo : Symbol(C.foo, Decl(file1.ts, 1, 9), Decl(file1.ts, 3, 33)) ->x : Symbol(x, Decl(file1.ts, 3, 15)) ->y : Symbol(y, Decl(file1.ts, 3, 25)) +>foo : Symbol(C.foo, Decl(file1.ts, 0, 9), Decl(file1.ts, 2, 33)) +>x : Symbol(x, Decl(file1.ts, 2, 15)) +>y : Symbol(y, Decl(file1.ts, 2, 25)) public foo(x: string, y: number) { } ->foo : Symbol(C.foo, Decl(file1.ts, 1, 9), Decl(file1.ts, 3, 33)) ->x : Symbol(x, Decl(file1.ts, 4, 15)) ->y : Symbol(y, Decl(file1.ts, 4, 25)) +>foo : Symbol(C.foo, Decl(file1.ts, 0, 9), Decl(file1.ts, 2, 33)) +>x : Symbol(x, Decl(file1.ts, 3, 15)) +>y : Symbol(y, Decl(file1.ts, 3, 25)) } var x = 10; ->x : Symbol(x, Decl(file1.ts, 7, 3)) +>x : Symbol(x, Decl(file1.ts, 6, 3)) /*! remove pinned comment anywhere else */ declare var OData: any; ->OData : Symbol(OData, Decl(file1.ts, 10, 11)) +>OData : Symbol(OData, Decl(file1.ts, 9, 11)) diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.types b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.types index 491ccdbd0d0d9..8da544663af72 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.types +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNode.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - class C { >C : C diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.js b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.js index 3198699405d94..a93a9911c4de9 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.js +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.js @@ -1,5 +1,4 @@ //// [doNotEmitPinnedCommentOnNotEmittedNodets.ts] - class C { /*! remove pinned comment anywhere else */ public foo(x: string, y: any) diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.symbols b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.symbols index 7b96fc028b1a3..0e3cdc1eb9f25 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.symbols +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/doNotEmitPinnedCommentOnNotEmittedNodets.ts === - class C { >C : Symbol(C, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 0, 0)) /*! remove pinned comment anywhere else */ public foo(x: string, y: any) ->foo : Symbol(C.foo, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 1, 9), Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 33)) ->x : Symbol(x, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 15)) ->y : Symbol(y, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 25)) +>foo : Symbol(C.foo, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 0, 9), Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 2, 33)) +>x : Symbol(x, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 2, 15)) +>y : Symbol(y, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 2, 25)) public foo(x: string, y: number) { } ->foo : Symbol(C.foo, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 1, 9), Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 33)) ->x : Symbol(x, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 4, 15)) ->y : Symbol(y, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 4, 25)) +>foo : Symbol(C.foo, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 0, 9), Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 2, 33)) +>x : Symbol(x, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 15)) +>y : Symbol(y, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 3, 25)) } /*! remove pinned comment anywhere else */ declare var OData: any; ->OData : Symbol(OData, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 8, 11)) +>OData : Symbol(OData, Decl(doNotEmitPinnedCommentOnNotEmittedNodets.ts, 7, 11)) diff --git a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.types b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.types index 4369af63f5366..32391644dcd3f 100644 --- a/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.types +++ b/tests/baselines/reference/doNotEmitPinnedCommentOnNotEmittedNodets.types @@ -1,5 +1,4 @@ === tests/cases/compiler/doNotEmitPinnedCommentOnNotEmittedNodets.ts === - class C { >C : C diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.js b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.js index f3b0888a78fb6..eaa9cd065145f 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.js +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/doNotEmitTripleSlashCommentsInEmptyFile.ts] //// //// [file0.ts] - //// [file1.ts] diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.symbols b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.symbols index d18810db2805b..5e3ebab68db05 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.symbols +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.symbols @@ -4,7 +4,6 @@ No type information for this code./// No type information for this code./// No type information for this code.=== tests/cases/compiler/file0.ts === -No type information for this code. No type information for this code.=== tests/cases/compiler/file1.ts === No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.types b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.types index d18810db2805b..5e3ebab68db05 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.types +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsInEmptyFile.types @@ -4,7 +4,6 @@ No type information for this code./// No type information for this code./// No type information for this code.=== tests/cases/compiler/file0.ts === -No type information for this code. No type information for this code.=== tests/cases/compiler/file1.ts === No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.js b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.js index 9067b5b80a978..57727cfd1870d 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.js +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/doNotEmitTripleSlashCommentsOnNotEmittedNode.ts] //// //// [file0.ts] - /// declare var OData: any; diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.symbols b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.symbols index bb920d2ee1c62..c4005efd09067 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.symbols +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.symbols @@ -5,8 +5,7 @@ interface F { } === tests/cases/compiler/file0.ts === - /// declare var OData: any; ->OData : Symbol(OData, Decl(file0.ts, 2, 11)) +>OData : Symbol(OData, Decl(file0.ts, 1, 11)) diff --git a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.types b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.types index 59b63ea1a2fd1..cdaa7ba436814 100644 --- a/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.types +++ b/tests/baselines/reference/doNotEmitTripleSlashCommentsOnNotEmittedNode.types @@ -5,7 +5,6 @@ interface F { } === tests/cases/compiler/file0.ts === - /// declare var OData: any; >OData : any diff --git a/tests/baselines/reference/doNotemitTripleSlashComments.js b/tests/baselines/reference/doNotemitTripleSlashComments.js index fe17db54cb1ac..f3f7440190264 100644 --- a/tests/baselines/reference/doNotemitTripleSlashComments.js +++ b/tests/baselines/reference/doNotemitTripleSlashComments.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/doNotemitTripleSlashComments.ts] //// //// [file0.ts] - /// /// /// diff --git a/tests/baselines/reference/doNotemitTripleSlashComments.symbols b/tests/baselines/reference/doNotemitTripleSlashComments.symbols index 36b31842f8b1f..0b8884b8c21b7 100644 --- a/tests/baselines/reference/doNotemitTripleSlashComments.symbols +++ b/tests/baselines/reference/doNotemitTripleSlashComments.symbols @@ -11,16 +11,15 @@ function bar() { } === tests/cases/compiler/file0.ts === - /// /// /// var x = 10; ->x : Symbol(x, Decl(file0.ts, 4, 3)) +>x : Symbol(x, Decl(file0.ts, 3, 3)) /// var y = "hello"; ->y : Symbol(y, Decl(file0.ts, 7, 3)) +>y : Symbol(y, Decl(file0.ts, 6, 3)) /// diff --git a/tests/baselines/reference/doNotemitTripleSlashComments.types b/tests/baselines/reference/doNotemitTripleSlashComments.types index 8bad6e601de68..09553ac9295a7 100644 --- a/tests/baselines/reference/doNotemitTripleSlashComments.types +++ b/tests/baselines/reference/doNotemitTripleSlashComments.types @@ -11,7 +11,6 @@ function bar() { } === tests/cases/compiler/file0.ts === - /// /// /// diff --git a/tests/baselines/reference/doWhileBreakStatements.js b/tests/baselines/reference/doWhileBreakStatements.js index 8e272ceed0a55..a2bc0d3c549af 100644 --- a/tests/baselines/reference/doWhileBreakStatements.js +++ b/tests/baselines/reference/doWhileBreakStatements.js @@ -1,5 +1,4 @@ //// [doWhileBreakStatements.ts] - do { break; } while(true) diff --git a/tests/baselines/reference/doWhileBreakStatements.symbols b/tests/baselines/reference/doWhileBreakStatements.symbols index 14db540598df2..7d9db9a5ebb51 100644 --- a/tests/baselines/reference/doWhileBreakStatements.symbols +++ b/tests/baselines/reference/doWhileBreakStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts === - do { break; } while(true) @@ -35,7 +34,7 @@ do do do break SEVEN; while (true) while (true) while (true) EIGHT: do{ var fn = function () { } ->fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 35, 7)) +>fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 34, 7)) break EIGHT; }while(true) diff --git a/tests/baselines/reference/doWhileBreakStatements.types b/tests/baselines/reference/doWhileBreakStatements.types index bc5102dc330fa..09f7794310f29 100644 --- a/tests/baselines/reference/doWhileBreakStatements.types +++ b/tests/baselines/reference/doWhileBreakStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts === - do { break; } while(true) diff --git a/tests/baselines/reference/doWhileContinueStatements.js b/tests/baselines/reference/doWhileContinueStatements.js index 51bac3c4e0913..7f73157fd994f 100644 --- a/tests/baselines/reference/doWhileContinueStatements.js +++ b/tests/baselines/reference/doWhileContinueStatements.js @@ -1,5 +1,4 @@ //// [doWhileContinueStatements.ts] - do { continue; } while(true) diff --git a/tests/baselines/reference/doWhileContinueStatements.symbols b/tests/baselines/reference/doWhileContinueStatements.symbols index 36ca2dde764d7..e4c6d577d5aa4 100644 --- a/tests/baselines/reference/doWhileContinueStatements.symbols +++ b/tests/baselines/reference/doWhileContinueStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts === - do { continue; } while(true) @@ -35,7 +34,7 @@ do do do continue SEVEN; while (true) while (true) while (true) EIGHT: do{ var fn = function () { } ->fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 35, 7)) +>fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 34, 7)) continue EIGHT; }while(true) diff --git a/tests/baselines/reference/doWhileContinueStatements.types b/tests/baselines/reference/doWhileContinueStatements.types index 66ff052a3cd6f..c0cd272afcd75 100644 --- a/tests/baselines/reference/doWhileContinueStatements.types +++ b/tests/baselines/reference/doWhileContinueStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts === - do { continue; } while(true) diff --git a/tests/baselines/reference/downlevelLetConst12.errors.txt b/tests/baselines/reference/downlevelLetConst12.errors.txt index 0af224b017e83..7d5c682820795 100644 --- a/tests/baselines/reference/downlevelLetConst12.errors.txt +++ b/tests/baselines/reference/downlevelLetConst12.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/downlevelLetConst12.ts(7,6): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/compiler/downlevelLetConst12.ts(10,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst12.ts(6,6): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst12.ts(9,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. ==== tests/cases/compiler/downlevelLetConst12.ts (2 errors) ==== - 'use strict' // top level let\const should not be renamed let foo; diff --git a/tests/baselines/reference/downlevelLetConst12.js b/tests/baselines/reference/downlevelLetConst12.js index bd0ab2fb46f7f..bdc33aaba9d64 100644 --- a/tests/baselines/reference/downlevelLetConst12.js +++ b/tests/baselines/reference/downlevelLetConst12.js @@ -1,5 +1,4 @@ //// [downlevelLetConst12.ts] - 'use strict' // top level let\const should not be renamed let foo; diff --git a/tests/baselines/reference/downlevelLetConst13.js b/tests/baselines/reference/downlevelLetConst13.js index 324c0cd9293b0..251468519ad04 100644 --- a/tests/baselines/reference/downlevelLetConst13.js +++ b/tests/baselines/reference/downlevelLetConst13.js @@ -1,5 +1,4 @@ //// [downlevelLetConst13.ts] - 'use strict' // exported let\const bindings should not be renamed diff --git a/tests/baselines/reference/downlevelLetConst13.symbols b/tests/baselines/reference/downlevelLetConst13.symbols index f8cd2e548a979..b4c3ce743f3fb 100644 --- a/tests/baselines/reference/downlevelLetConst13.symbols +++ b/tests/baselines/reference/downlevelLetConst13.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/downlevelLetConst13.ts === - 'use strict' // exported let\const bindings should not be renamed export let foo = 10; ->foo : Symbol(foo, Decl(downlevelLetConst13.ts, 4, 10)) +>foo : Symbol(foo, Decl(downlevelLetConst13.ts, 3, 10)) export const bar = "123" ->bar : Symbol(bar, Decl(downlevelLetConst13.ts, 5, 12)) +>bar : Symbol(bar, Decl(downlevelLetConst13.ts, 4, 12)) export let [bar1] = [1]; ->bar1 : Symbol(bar1, Decl(downlevelLetConst13.ts, 6, 12)) +>bar1 : Symbol(bar1, Decl(downlevelLetConst13.ts, 5, 12)) export const [bar2] = [2]; ->bar2 : Symbol(bar2, Decl(downlevelLetConst13.ts, 7, 14)) +>bar2 : Symbol(bar2, Decl(downlevelLetConst13.ts, 6, 14)) export let {a: bar3} = { a: 1 }; ->a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 24)) ->bar3 : Symbol(bar3, Decl(downlevelLetConst13.ts, 8, 12)) ->a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 24)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 7, 24)) +>bar3 : Symbol(bar3, Decl(downlevelLetConst13.ts, 7, 12)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 7, 24)) export const {a: bar4} = { a: 1 }; ->a : Symbol(a, Decl(downlevelLetConst13.ts, 9, 26)) ->bar4 : Symbol(bar4, Decl(downlevelLetConst13.ts, 9, 14)) ->a : Symbol(a, Decl(downlevelLetConst13.ts, 9, 26)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 26)) +>bar4 : Symbol(bar4, Decl(downlevelLetConst13.ts, 8, 14)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 26)) export module M { ->M : Symbol(M, Decl(downlevelLetConst13.ts, 9, 34)) +>M : Symbol(M, Decl(downlevelLetConst13.ts, 8, 34)) export let baz = 100; ->baz : Symbol(baz, Decl(downlevelLetConst13.ts, 12, 14)) +>baz : Symbol(baz, Decl(downlevelLetConst13.ts, 11, 14)) export const baz2 = true; ->baz2 : Symbol(baz2, Decl(downlevelLetConst13.ts, 13, 16)) +>baz2 : Symbol(baz2, Decl(downlevelLetConst13.ts, 12, 16)) export let [bar5] = [1]; ->bar5 : Symbol(bar5, Decl(downlevelLetConst13.ts, 14, 16)) +>bar5 : Symbol(bar5, Decl(downlevelLetConst13.ts, 13, 16)) export const [bar6] = [2]; ->bar6 : Symbol(bar6, Decl(downlevelLetConst13.ts, 15, 18)) +>bar6 : Symbol(bar6, Decl(downlevelLetConst13.ts, 14, 18)) export let {a: bar7} = { a: 1 }; ->a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 28)) ->bar7 : Symbol(bar7, Decl(downlevelLetConst13.ts, 16, 16)) ->a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 28)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 15, 28)) +>bar7 : Symbol(bar7, Decl(downlevelLetConst13.ts, 15, 16)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 15, 28)) export const {a: bar8} = { a: 1 }; ->a : Symbol(a, Decl(downlevelLetConst13.ts, 17, 30)) ->bar8 : Symbol(bar8, Decl(downlevelLetConst13.ts, 17, 18)) ->a : Symbol(a, Decl(downlevelLetConst13.ts, 17, 30)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 30)) +>bar8 : Symbol(bar8, Decl(downlevelLetConst13.ts, 16, 18)) +>a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 30)) } diff --git a/tests/baselines/reference/downlevelLetConst13.types b/tests/baselines/reference/downlevelLetConst13.types index 92bb3226f94d5..47307d504e5f0 100644 --- a/tests/baselines/reference/downlevelLetConst13.types +++ b/tests/baselines/reference/downlevelLetConst13.types @@ -1,5 +1,4 @@ === tests/cases/compiler/downlevelLetConst13.ts === - 'use strict' >'use strict' : "use strict" diff --git a/tests/baselines/reference/downlevelLetConst16.errors.txt b/tests/baselines/reference/downlevelLetConst16.errors.txt index a6ada633016ff..905d1a607e81d 100644 --- a/tests/baselines/reference/downlevelLetConst16.errors.txt +++ b/tests/baselines/reference/downlevelLetConst16.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/downlevelLetConst16.ts(152,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/compiler/downlevelLetConst16.ts(165,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/compiler/downlevelLetConst16.ts(196,14): error TS2461: Type 'undefined' is not an array type. -tests/cases/compiler/downlevelLetConst16.ts(203,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature. -tests/cases/compiler/downlevelLetConst16.ts(217,16): error TS2461: Type 'undefined' is not an array type. -tests/cases/compiler/downlevelLetConst16.ts(224,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature. +tests/cases/compiler/downlevelLetConst16.ts(151,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst16.ts(164,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst16.ts(195,14): error TS2461: Type 'undefined' is not an array type. +tests/cases/compiler/downlevelLetConst16.ts(202,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature. +tests/cases/compiler/downlevelLetConst16.ts(216,16): error TS2461: Type 'undefined' is not an array type. +tests/cases/compiler/downlevelLetConst16.ts(223,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature. ==== tests/cases/compiler/downlevelLetConst16.ts (6 errors) ==== - 'use strict' declare function use(a: any); diff --git a/tests/baselines/reference/downlevelLetConst16.js b/tests/baselines/reference/downlevelLetConst16.js index edc778209bef3..944bb192e906c 100644 --- a/tests/baselines/reference/downlevelLetConst16.js +++ b/tests/baselines/reference/downlevelLetConst16.js @@ -1,5 +1,4 @@ //// [downlevelLetConst16.ts] - 'use strict' declare function use(a: any); diff --git a/tests/baselines/reference/downlevelLetConst18.errors.txt b/tests/baselines/reference/downlevelLetConst18.errors.txt index 5b91498f17386..3c3ae0e01e991 100644 --- a/tests/baselines/reference/downlevelLetConst18.errors.txt +++ b/tests/baselines/reference/downlevelLetConst18.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/downlevelLetConst18.ts(5,14): error TS1250: Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. -tests/cases/compiler/downlevelLetConst18.ts(9,14): error TS1250: Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. +tests/cases/compiler/downlevelLetConst18.ts(4,14): error TS1250: Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. +tests/cases/compiler/downlevelLetConst18.ts(8,14): error TS1250: Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. ==== tests/cases/compiler/downlevelLetConst18.ts (2 errors) ==== - 'use strict' for (let x; ;) { diff --git a/tests/baselines/reference/downlevelLetConst18.js b/tests/baselines/reference/downlevelLetConst18.js index 7dcd563f759b1..9827efdbc953a 100644 --- a/tests/baselines/reference/downlevelLetConst18.js +++ b/tests/baselines/reference/downlevelLetConst18.js @@ -1,5 +1,4 @@ //// [downlevelLetConst18.ts] - 'use strict' for (let x; ;) { diff --git a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.errors.txt b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.errors.txt index d210588234da7..94c5a9a8e3808 100644 --- a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.errors.txt +++ b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.errors.txt @@ -1,28 +1,27 @@ -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,13): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(1,13): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(1,17): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(1,21): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(1,27): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,14): error TS2300: Duplicate identifier 'a'. tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,17): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,21): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(2,27): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(3,14): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(3,17): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,14): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,19): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,14): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,17): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,22): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,14): error TS2300: Duplicate identifier 'd'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,20): error TS2300: Duplicate identifier 'd'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,14): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,21): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,27): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,34): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,39): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,48): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(8,14): error TS2300: Duplicate identifier 'f'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(8,20): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(3,14): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(3,19): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,14): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,17): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(4,22): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,14): error TS2300: Duplicate identifier 'd'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(5,20): error TS2300: Duplicate identifier 'd'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,14): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,21): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,27): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,34): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,39): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(6,48): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,14): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts(7,20): error TS2300: Duplicate identifier 'f'. ==== tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration1.ts (21 errors) ==== - function f0(a, [a, [b]], {b}) { } ~ !!! error TS2300: Duplicate identifier 'a'. diff --git a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.js b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.js index 0c1eb5f321005..639f4df7880b2 100644 --- a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.js +++ b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.js @@ -1,5 +1,4 @@ //// [duplicateIdentifierBindingElementInParameterDeclaration1.ts] - function f0(a, [a, [b]], {b}) { } function f1([a, a]) { } function f2({b}, {b}) { } diff --git a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.errors.txt b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.errors.txt index e3d1dc621f8ee..00720540de7ee 100644 --- a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.errors.txt +++ b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.errors.txt @@ -1,28 +1,27 @@ -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,13): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(2,13): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(2,17): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(2,21): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(2,27): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,14): error TS2300: Duplicate identifier 'a'. tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,17): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,21): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(3,27): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(4,14): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(4,17): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,14): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,19): error TS2300: Duplicate identifier 'b'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,14): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,18): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,24): error TS2300: Duplicate identifier 'c'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,14): error TS2300: Duplicate identifier 'd'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,21): error TS2300: Duplicate identifier 'd'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,14): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,21): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,27): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,35): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,40): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,49): error TS2300: Duplicate identifier 'e'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(9,14): error TS2300: Duplicate identifier 'f'. -tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(9,20): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(4,14): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(4,19): error TS2300: Duplicate identifier 'b'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,14): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,18): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(5,24): error TS2300: Duplicate identifier 'c'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,14): error TS2300: Duplicate identifier 'd'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(6,21): error TS2300: Duplicate identifier 'd'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,14): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,21): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,27): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,35): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,40): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(7,49): error TS2300: Duplicate identifier 'e'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,14): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts(8,20): error TS2300: Duplicate identifier 'f'. ==== tests/cases/compiler/duplicateIdentifierBindingElementInParameterDeclaration2.ts (21 errors) ==== - "use strict" function f0(a, [a, [b]], {b}) { } ~ diff --git a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.js b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.js index e423b035d9d03..caaf482d26933 100644 --- a/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.js +++ b/tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.js @@ -1,5 +1,4 @@ //// [duplicateIdentifierBindingElementInParameterDeclaration2.ts] - "use strict" function f0(a, [a, [b]], {b}) { } function f1([a, a]) { } diff --git a/tests/baselines/reference/duplicateIdentifierDifferentSpelling.js b/tests/baselines/reference/duplicateIdentifierDifferentSpelling.js index 96e5781919deb..0bd30fe2fcaa8 100644 --- a/tests/baselines/reference/duplicateIdentifierDifferentSpelling.js +++ b/tests/baselines/reference/duplicateIdentifierDifferentSpelling.js @@ -10,7 +10,7 @@ var X = { 0b11: '', 3: '' }; //// [duplicateIdentifierDifferentSpelling.js] var A = (function () { function A() { - this[3] = ''; + this[0b11] = ''; this[3] = ''; } return A; diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt index 7ef43dc64707e..400bafa3c1a75 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt @@ -1,6 +1,6 @@ -tests/cases/compiler/file1.ts(4,7): error TS2300: Duplicate identifier 'C2'. -tests/cases/compiler/file1.ts(5,10): error TS2300: Duplicate identifier 'f'. -tests/cases/compiler/file1.ts(9,12): error TS2300: Duplicate identifier 'x'. +tests/cases/compiler/file1.ts(3,7): error TS2300: Duplicate identifier 'C2'. +tests/cases/compiler/file1.ts(4,10): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/file1.ts(8,12): error TS2300: Duplicate identifier 'x'. tests/cases/compiler/file2.ts(3,10): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/file2.ts(4,7): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/file2.ts(7,8): error TS2433: A namespace declaration cannot be in a different file from a class or function with which it is merged. @@ -8,7 +8,6 @@ tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. ==== tests/cases/compiler/file1.ts (3 errors) ==== - interface I { } class C1 { } class C2 { } diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js index 70635dcbd7e5a..eb1eeb9b30236 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/duplicateIdentifiersAcrossFileBoundaries.ts] //// //// [file1.ts] - interface I { } class C1 { } class C2 { } diff --git a/tests/baselines/reference/duplicateLabel1.errors.txt b/tests/baselines/reference/duplicateLabel1.errors.txt index 03d4e999597b3..5f52933e1d652 100644 --- a/tests/baselines/reference/duplicateLabel1.errors.txt +++ b/tests/baselines/reference/duplicateLabel1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/duplicateLabel1.ts(3,1): error TS1114: Duplicate label 'target'. +tests/cases/compiler/duplicateLabel1.ts(2,1): error TS1114: Duplicate label 'target'. ==== tests/cases/compiler/duplicateLabel1.ts (1 errors) ==== - target: target: ~~~~~~ diff --git a/tests/baselines/reference/duplicateLabel1.js b/tests/baselines/reference/duplicateLabel1.js index 5251cec3e3683..e7976895c94d8 100644 --- a/tests/baselines/reference/duplicateLabel1.js +++ b/tests/baselines/reference/duplicateLabel1.js @@ -1,5 +1,4 @@ //// [duplicateLabel1.ts] - target: target: while (true) { diff --git a/tests/baselines/reference/duplicateLabel2.errors.txt b/tests/baselines/reference/duplicateLabel2.errors.txt index d178a8ffe5cee..bc64c9c323b9e 100644 --- a/tests/baselines/reference/duplicateLabel2.errors.txt +++ b/tests/baselines/reference/duplicateLabel2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/duplicateLabel2.ts(4,3): error TS1114: Duplicate label 'target'. +tests/cases/compiler/duplicateLabel2.ts(3,3): error TS1114: Duplicate label 'target'. ==== tests/cases/compiler/duplicateLabel2.ts (1 errors) ==== - target: while (true) { target: diff --git a/tests/baselines/reference/duplicateLabel2.js b/tests/baselines/reference/duplicateLabel2.js index 40a5ee4595e76..9ee9671d59de8 100644 --- a/tests/baselines/reference/duplicateLabel2.js +++ b/tests/baselines/reference/duplicateLabel2.js @@ -1,5 +1,4 @@ //// [duplicateLabel2.ts] - target: while (true) { target: diff --git a/tests/baselines/reference/duplicateLabel3.js b/tests/baselines/reference/duplicateLabel3.js index a1d33e46fc19b..37e9619e8f6bb 100644 --- a/tests/baselines/reference/duplicateLabel3.js +++ b/tests/baselines/reference/duplicateLabel3.js @@ -1,5 +1,4 @@ //// [duplicateLabel3.ts] - target: while (true) { function f() { diff --git a/tests/baselines/reference/duplicateLabel3.symbols b/tests/baselines/reference/duplicateLabel3.symbols index 89f2d5ee48a69..07d0ded29232e 100644 --- a/tests/baselines/reference/duplicateLabel3.symbols +++ b/tests/baselines/reference/duplicateLabel3.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/duplicateLabel3.ts === - target: while (true) { function f() { ->f : Symbol(f, Decl(duplicateLabel3.ts, 2, 14)) +>f : Symbol(f, Decl(duplicateLabel3.ts, 1, 14)) target: while (true) { diff --git a/tests/baselines/reference/duplicateLabel3.types b/tests/baselines/reference/duplicateLabel3.types index 56af6f24088c3..bc82f79581146 100644 --- a/tests/baselines/reference/duplicateLabel3.types +++ b/tests/baselines/reference/duplicateLabel3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/duplicateLabel3.ts === - target: >target : any diff --git a/tests/baselines/reference/duplicateLabel4.js b/tests/baselines/reference/duplicateLabel4.js index d5b81b1e5bb8f..22d072d38d730 100644 --- a/tests/baselines/reference/duplicateLabel4.js +++ b/tests/baselines/reference/duplicateLabel4.js @@ -1,5 +1,4 @@ //// [duplicateLabel4.ts] - target: while (true) { } diff --git a/tests/baselines/reference/duplicateLabel4.symbols b/tests/baselines/reference/duplicateLabel4.symbols index 5660782e2ecdd..c671abcef35d6 100644 --- a/tests/baselines/reference/duplicateLabel4.symbols +++ b/tests/baselines/reference/duplicateLabel4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/duplicateLabel4.ts === - -No type information for this code.target: +target: No type information for this code.while (true) { No type information for this code.} No type information for this code. diff --git a/tests/baselines/reference/duplicateLabel4.types b/tests/baselines/reference/duplicateLabel4.types index 2f5890ae9a42f..db82656f84efa 100644 --- a/tests/baselines/reference/duplicateLabel4.types +++ b/tests/baselines/reference/duplicateLabel4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/duplicateLabel4.ts === - target: >target : any diff --git a/tests/baselines/reference/duplicateLocalVariable1.errors.txt b/tests/baselines/reference/duplicateLocalVariable1.errors.txt index b264574ea0983..0486cd1af6032 100644 --- a/tests/baselines/reference/duplicateLocalVariable1.errors.txt +++ b/tests/baselines/reference/duplicateLocalVariable1.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/duplicateLocalVariable1.ts(2,4): error TS1005: ';' expected. -tests/cases/compiler/duplicateLocalVariable1.ts(2,11): error TS1146: Declaration expected. -tests/cases/compiler/duplicateLocalVariable1.ts(2,13): error TS2304: Cannot find name 'commonjs'. -tests/cases/compiler/duplicateLocalVariable1.ts(187,22): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'string', but here has type 'number'. -tests/cases/compiler/duplicateLocalVariable1.ts(187,29): error TS2365: Operator '<' cannot be applied to types 'string' and 'number'. -tests/cases/compiler/duplicateLocalVariable1.ts(187,37): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/compiler/duplicateLocalVariable1.ts(1,4): error TS1005: ';' expected. +tests/cases/compiler/duplicateLocalVariable1.ts(1,11): error TS1146: Declaration expected. +tests/cases/compiler/duplicateLocalVariable1.ts(1,13): error TS2304: Cannot find name 'commonjs'. +tests/cases/compiler/duplicateLocalVariable1.ts(186,22): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'string', but here has type 'number'. +tests/cases/compiler/duplicateLocalVariable1.ts(186,29): error TS2365: Operator '<' cannot be applied to types 'string' and 'number'. +tests/cases/compiler/duplicateLocalVariable1.ts(186,37): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. ==== tests/cases/compiler/duplicateLocalVariable1.ts (6 errors) ==== - / /@module: commonjs ~ !!! error TS1005: ';' expected. diff --git a/tests/baselines/reference/duplicateLocalVariable1.js b/tests/baselines/reference/duplicateLocalVariable1.js index c1417de9dfef6..61e8dcd02f872 100644 --- a/tests/baselines/reference/duplicateLocalVariable1.js +++ b/tests/baselines/reference/duplicateLocalVariable1.js @@ -1,5 +1,4 @@ //// [duplicateLocalVariable1.ts] - / /@module: commonjs //import FileManager = require('filemanager'); diff --git a/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.errors.txt b/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.errors.txt index 80b108bbd666f..91b808759df33 100644 --- a/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.errors.txt +++ b/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(2,11): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(2,22): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(1,11): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(1,22): error TS2300: Duplicate identifier 'a'. ==== tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts (2 errors) ==== - let x = <{a: number; a: number}>{}; ~ !!! error TS2300: Duplicate identifier 'a'. diff --git a/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.js b/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.js index 03f46ad110ac1..e0b54e6205871 100644 --- a/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.js +++ b/tests/baselines/reference/duplicatePropertiesInTypeAssertions01.js @@ -1,5 +1,4 @@ //// [duplicatePropertiesInTypeAssertions01.ts] - let x = <{a: number; a: number}>{}; //// [duplicatePropertiesInTypeAssertions01.js] diff --git a/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.errors.txt b/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.errors.txt index eeb9ffa930245..a979da4a8315f 100644 --- a/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.errors.txt +++ b/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(2,16): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(2,27): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(1,16): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(1,27): error TS2300: Duplicate identifier 'a'. ==== tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts (2 errors) ==== - let x = {} as {a: number; a: number}; ~ !!! error TS2300: Duplicate identifier 'a'. diff --git a/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.js b/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.js index 8aa4449595ab1..8fe55ed046ece 100644 --- a/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.js +++ b/tests/baselines/reference/duplicatePropertiesInTypeAssertions02.js @@ -1,5 +1,4 @@ //// [duplicatePropertiesInTypeAssertions02.ts] - let x = {} as {a: number; a: number}; //// [duplicatePropertiesInTypeAssertions02.js] diff --git a/tests/baselines/reference/duplicateVariablesByScope.js b/tests/baselines/reference/duplicateVariablesByScope.js index 2f9a0348811cc..ed6b7834a1d25 100644 --- a/tests/baselines/reference/duplicateVariablesByScope.js +++ b/tests/baselines/reference/duplicateVariablesByScope.js @@ -1,5 +1,4 @@ //// [duplicateVariablesByScope.ts] - // duplicate local variables are only reported at global scope module M { diff --git a/tests/baselines/reference/duplicateVariablesByScope.symbols b/tests/baselines/reference/duplicateVariablesByScope.symbols index 88eb44d018164..abc4a9580e4d6 100644 --- a/tests/baselines/reference/duplicateVariablesByScope.symbols +++ b/tests/baselines/reference/duplicateVariablesByScope.symbols @@ -1,57 +1,56 @@ === tests/cases/compiler/duplicateVariablesByScope.ts === - // duplicate local variables are only reported at global scope module M { >M : Symbol(M, Decl(duplicateVariablesByScope.ts, 0, 0)) for (var j = 0; j < 10; j++) { ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) } for (var j = 0; j < 10; j++) { ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) } } function foo() { ->foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 9, 1)) +>foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 8, 1)) var x = 2; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 11, 7), Decl(duplicateVariablesByScope.ts, 12, 7)) var x = 1; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 11, 7), Decl(duplicateVariablesByScope.ts, 12, 7)) if (true) { var result = 1; ->result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11)) +>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 14, 11), Decl(duplicateVariablesByScope.ts, 17, 11)) } else { var result = 2; ->result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11)) +>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 14, 11), Decl(duplicateVariablesByScope.ts, 17, 11)) } } class C { ->C : Symbol(C, Decl(duplicateVariablesByScope.ts, 20, 1)) +>C : Symbol(C, Decl(duplicateVariablesByScope.ts, 19, 1)) foo() { ->foo : Symbol(C.foo, Decl(duplicateVariablesByScope.ts, 22, 9)) +>foo : Symbol(C.foo, Decl(duplicateVariablesByScope.ts, 21, 9)) try { var x = 1; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 24, 15), Decl(duplicateVariablesByScope.ts, 27, 15)) } catch (e) { ->e : Symbol(e, Decl(duplicateVariablesByScope.ts, 27, 15)) +>e : Symbol(e, Decl(duplicateVariablesByScope.ts, 26, 15)) var x = 2; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 24, 15), Decl(duplicateVariablesByScope.ts, 27, 15)) } } } diff --git a/tests/baselines/reference/duplicateVariablesByScope.types b/tests/baselines/reference/duplicateVariablesByScope.types index 4eec3a2054f3f..6993827d4f8a5 100644 --- a/tests/baselines/reference/duplicateVariablesByScope.types +++ b/tests/baselines/reference/duplicateVariablesByScope.types @@ -1,5 +1,4 @@ === tests/cases/compiler/duplicateVariablesByScope.ts === - // duplicate local variables are only reported at global scope module M { diff --git a/tests/baselines/reference/dynamicRequire.js b/tests/baselines/reference/dynamicRequire.js index 28b359706013f..36737ff7a04e3 100644 --- a/tests/baselines/reference/dynamicRequire.js +++ b/tests/baselines/reference/dynamicRequire.js @@ -1,5 +1,4 @@ //// [a.js] - function foo(name) { var s = require("t/" + name) } diff --git a/tests/baselines/reference/dynamicRequire.symbols b/tests/baselines/reference/dynamicRequire.symbols index c307d578de7d1..ba593556f259b 100644 --- a/tests/baselines/reference/dynamicRequire.symbols +++ b/tests/baselines/reference/dynamicRequire.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/a.js === - function foo(name) { >foo : Symbol(foo, Decl(a.js, 0, 0)) ->name : Symbol(name, Decl(a.js, 1, 13)) +>name : Symbol(name, Decl(a.js, 0, 13)) var s = require("t/" + name) ->s : Symbol(s, Decl(a.js, 2, 7)) ->name : Symbol(name, Decl(a.js, 1, 13)) +>s : Symbol(s, Decl(a.js, 1, 7)) +>name : Symbol(name, Decl(a.js, 0, 13)) } diff --git a/tests/baselines/reference/dynamicRequire.types b/tests/baselines/reference/dynamicRequire.types index 9b7a6c359d53d..298563f73a239 100644 --- a/tests/baselines/reference/dynamicRequire.types +++ b/tests/baselines/reference/dynamicRequire.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - function foo(name) { >foo : (name: any) => void >name : any diff --git a/tests/baselines/reference/elidingImportNames.js b/tests/baselines/reference/elidingImportNames.js index f878c5044eaeb..6b1d7968c9bb6 100644 --- a/tests/baselines/reference/elidingImportNames.js +++ b/tests/baselines/reference/elidingImportNames.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/elidingImportNames.ts] //// //// [elidingImportNames_test.ts] - import a = require('./elidingImportNames_main'); // alias used in typeof var b = a; var x: typeof a; diff --git a/tests/baselines/reference/elidingImportNames.symbols b/tests/baselines/reference/elidingImportNames.symbols index d9cdcd61ffe54..1432e500c4d9f 100644 --- a/tests/baselines/reference/elidingImportNames.symbols +++ b/tests/baselines/reference/elidingImportNames.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/elidingImportNames_test.ts === - import a = require('./elidingImportNames_main'); // alias used in typeof >a : Symbol(a, Decl(elidingImportNames_test.ts, 0, 0)) var b = a; ->b : Symbol(b, Decl(elidingImportNames_test.ts, 2, 3)) +>b : Symbol(b, Decl(elidingImportNames_test.ts, 1, 3)) >a : Symbol(a, Decl(elidingImportNames_test.ts, 0, 0)) var x: typeof a; ->x : Symbol(x, Decl(elidingImportNames_test.ts, 3, 3)) +>x : Symbol(x, Decl(elidingImportNames_test.ts, 2, 3)) >a : Symbol(a, Decl(elidingImportNames_test.ts, 0, 0)) import a2 = require('./elidingImportNames_main1'); // alias not used in typeof ->a2 : Symbol(a2, Decl(elidingImportNames_test.ts, 3, 16)) +>a2 : Symbol(a2, Decl(elidingImportNames_test.ts, 2, 16)) var b2 = a2; ->b2 : Symbol(b2, Decl(elidingImportNames_test.ts, 5, 3)) ->a2 : Symbol(a2, Decl(elidingImportNames_test.ts, 3, 16)) +>b2 : Symbol(b2, Decl(elidingImportNames_test.ts, 4, 3)) +>a2 : Symbol(a2, Decl(elidingImportNames_test.ts, 2, 16)) === tests/cases/compiler/elidingImportNames_main.ts === diff --git a/tests/baselines/reference/elidingImportNames.types b/tests/baselines/reference/elidingImportNames.types index 8dd6b31513747..927020b849c3c 100644 --- a/tests/baselines/reference/elidingImportNames.types +++ b/tests/baselines/reference/elidingImportNames.types @@ -1,5 +1,4 @@ === tests/cases/compiler/elidingImportNames_test.ts === - import a = require('./elidingImportNames_main'); // alias used in typeof >a : typeof a diff --git a/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.js b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.js new file mode 100644 index 0000000000000..182e678b7bfc6 --- /dev/null +++ b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.js @@ -0,0 +1,7 @@ +//// [emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.ts] +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string })[x]; +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string }).x; + +//// [emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.js] +(function (x) { return ({ "1": "one", "2": "two" }[x]); }); +(function (x) { return ({ "1": "one", "2": "two" }.x); }); diff --git a/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.symbols b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.symbols new file mode 100644 index 0000000000000..36803f0049015 --- /dev/null +++ b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.symbols @@ -0,0 +1,10 @@ +=== tests/cases/compiler/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.ts === +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string })[x]; +>x : Symbol(x, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.ts, 0, 1)) +>key : Symbol(key, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.ts, 0, 41)) +>x : Symbol(x, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.ts, 0, 1)) + +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string }).x; +>x : Symbol(x, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.ts, 1, 1)) +>key : Symbol(key, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.ts, 1, 41)) + diff --git a/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.types b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.types new file mode 100644 index 0000000000000..83637f261dee5 --- /dev/null +++ b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.types @@ -0,0 +1,25 @@ +=== tests/cases/compiler/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES5.ts === +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string })[x]; +>(x) => ({ "1": "one", "2": "two" } as { [key: string]: string })[x] : (x: any) => string +>x : any +>({ "1": "one", "2": "two" } as { [key: string]: string })[x] : string +>({ "1": "one", "2": "two" } as { [key: string]: string }) : { [key: string]: string; } +>{ "1": "one", "2": "two" } as { [key: string]: string } : { [key: string]: string; } +>{ "1": "one", "2": "two" } : { "1": string; "2": string; } +>"one" : "one" +>"two" : "two" +>key : string +>x : any + +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string }).x; +>(x) => ({ "1": "one", "2": "two" } as { [key: string]: string }).x : (x: any) => string +>x : any +>({ "1": "one", "2": "two" } as { [key: string]: string }).x : string +>({ "1": "one", "2": "two" } as { [key: string]: string }) : { [key: string]: string; } +>{ "1": "one", "2": "two" } as { [key: string]: string } : { [key: string]: string; } +>{ "1": "one", "2": "two" } : { "1": string; "2": string; } +>"one" : "one" +>"two" : "two" +>key : string +>x : string + diff --git a/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.js b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.js new file mode 100644 index 0000000000000..8d7999b0da767 --- /dev/null +++ b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.js @@ -0,0 +1,7 @@ +//// [emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.ts] +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string })[x]; +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string }).x; + +//// [emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.js] +(x) => ({ "1": "one", "2": "two" }[x]); +(x) => ({ "1": "one", "2": "two" }.x); diff --git a/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.symbols b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.symbols new file mode 100644 index 0000000000000..20b10f84a22ac --- /dev/null +++ b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/compiler/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.ts === +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string })[x]; +>x : Symbol(x, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.ts, 0, 1)) +>key : Symbol(key, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.ts, 0, 41)) +>x : Symbol(x, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.ts, 0, 1)) + +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string }).x; +>x : Symbol(x, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.ts, 1, 1)) +>key : Symbol(key, Decl(emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.ts, 1, 41)) + diff --git a/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.types b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.types new file mode 100644 index 0000000000000..f19255cd724eb --- /dev/null +++ b/tests/baselines/reference/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.types @@ -0,0 +1,25 @@ +=== tests/cases/compiler/emitAccessExpressionOfCastedObjectLiteralExpressionInArrowFunctionES6.ts === +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string })[x]; +>(x) => ({ "1": "one", "2": "two" } as { [key: string]: string })[x] : (x: any) => string +>x : any +>({ "1": "one", "2": "two" } as { [key: string]: string })[x] : string +>({ "1": "one", "2": "two" } as { [key: string]: string }) : { [key: string]: string; } +>{ "1": "one", "2": "two" } as { [key: string]: string } : { [key: string]: string; } +>{ "1": "one", "2": "two" } : { "1": string; "2": string; } +>"one" : "one" +>"two" : "two" +>key : string +>x : any + +(x) => ({ "1": "one", "2": "two" } as { [key: string]: string }).x; +>(x) => ({ "1": "one", "2": "two" } as { [key: string]: string }).x : (x: any) => string +>x : any +>({ "1": "one", "2": "two" } as { [key: string]: string }).x : string +>({ "1": "one", "2": "two" } as { [key: string]: string }) : { [key: string]: string; } +>{ "1": "one", "2": "two" } as { [key: string]: string } : { [key: string]: string; } +>{ "1": "one", "2": "two" } : { "1": string; "2": string; } +>"one" : "one" +>"two" : "two" +>key : string +>x : string + diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt index 55f0ce2230acd..29aab1314f88f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02.ts(1,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02.ts (1 errors) ==== - var a = () => arguments; ~~~~~~~~~ !!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js index b6774dd54076d..15c549ab05356 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments02.ts] - var a = () => arguments; //// [emitArrowFunctionWhenUsingArguments02.js] diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js index 0f35b8898b292..1396702ff7e43 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments02_ES6.ts] - var a = () => arguments; //// [emitArrowFunctionWhenUsingArguments02_ES6.js] diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols index e403a2c3da1a9..4843562aaece7 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02_ES6.ts === - var a = () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments02_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments02_ES6.ts, 0, 3)) >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.types index fe5ac353ce663..40859c33cc3f6 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02_ES6.ts === - var a = () => arguments; >a : () => IArguments >() => arguments : () => IArguments diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt index d914e14d93a35..3c1bb6b913bce 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03.ts(3,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03.ts (1 errors) ==== - var arguments; var a = () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js index 5b57f7acf0d22..2d8415b856b53 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments03.ts] - var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js index d4d35e7abdcd8..fbaf9cea89a0d 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments03_ES6.ts] - var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols index 08bae3827942b..71518083b1f89 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols @@ -1,9 +1,8 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03_ES6.ts === - var arguments; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 1, 3)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 0, 3)) var a = () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 2, 3)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 1, 3)) >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.types index 33a45a39af1d7..ad46bec71b6b1 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03_ES6.ts === - var arguments; >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt index 12e416f893f2d..62359b15cb506 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04.ts(4,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04.ts(3,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04.ts (1 errors) ==== - function f() { var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js index 588610a4022d9..e9a5e15d7185d 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments04.ts] - function f() { var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js index 63e896039c909..ca95bc230a90b 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments04_ES6.ts] - function f() { var arguments; var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols index 708615a95c606..d42db50fa3b81 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 0, 0)) var arguments; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 2, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 1, 7)) var a = () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 3, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 2, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.types index 495ca1582e6ef..e371862ee4de5 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04_ES6.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt index 4256dab30c206..97a34d3552238 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05.ts(3,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05.ts(2,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05.ts (1 errors) ==== - function f(arguments) { var a = () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js index b4ed2b383b766..38379a69cb210 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments05.ts] - function f(arguments) { var a = () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js index 9fe68e9bb4834..a6161822cac11 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments05_ES6.ts] - function f(arguments) { var a = () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols index 379a5cf92f128..cfa539d19489f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 0, 11)) var a = () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 1, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.types index 4e9da2f642b1c..bcb452f0940fc 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt index 5b078f22f4442..3ee3dbf275542 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06.ts(2,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06.ts (1 errors) ==== - function f(arguments) { var a = () => () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js index d004b77e947c8..cec5ba872893f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments06.ts] - function f(arguments) { var a = () => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js index 6b83e0c60d9de..859567f6d28e3 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments06_ES6.ts] - function f(arguments) { var a = () => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols index e59f487f86405..0aef2f06c45c7 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 0, 11)) var a = () => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 1, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.types index 82571174a1e3f..f29eb52f32b9c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt index da1f7dd28f91f..983e03876a0fe 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07.ts(3,34): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07.ts(2,34): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07.ts (1 errors) ==== - function f(arguments) { var a = (arguments) => () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js index 7f06036dfc177..836f4f6d75ebd 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments07.ts] - function f(arguments) { var a = (arguments) => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js index bdc8cf82d440c..95d92f2c2ff6f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments07_ES6.ts] - function f(arguments) { var a = (arguments) => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols index 5de21ffbebd53..4fdce2cccb117 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 0, 11)) var a = (arguments) => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 13)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 1, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 1, 13)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.types index 967631cc57b27..168ffac3c5e81 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js index dbb89d4eb6b94..130b8788fd699 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments08.ts] - function f(arguments) { var a = () => (arguments) => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols index 80f7f5079788d..a3a4c19db72ae 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments08.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 0, 11)) var a = () => (arguments) => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 19)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 19)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08.ts, 1, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 1, 19)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 1, 19)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types index 4b6d1e19b4abb..a6653e510ee1c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js index ee568185c0ae6..bb82cd9b369b6 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments08_ES6.ts] - function f(arguments) { var a = () => (arguments) => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols index bfbb055cc3249..f328046d934b7 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 0, 11)) var a = () => (arguments) => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 19)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 19)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 1, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 1, 19)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 1, 19)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types index ffa0f7f0bca81..532508c93dbe0 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt index 72239150cf369..8c2473128e521 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09.ts(2,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09.ts (1 errors) ==== - function f(_arguments) { var a = () => () => arguments; ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js index c879e6f1ce933..764a542637743 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments09.ts] - function f(_arguments) { var a = () => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js index 15932510d39a6..4b27e13649e8f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments09_ES6.ts] - function f(_arguments) { var a = () => () => arguments; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols index ff8f114c052e8..12ba6119b5ea6 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09_ES6.ts === - function f(_arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 0, 0)) ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 1, 11)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 0, 11)) var a = () => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 1, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.types index 77f44eebfcafd..bb867e477b0b0 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09_ES6.ts === - function f(_arguments) { >f : (_arguments: any) => void >_arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt index 254ad2cbc4dc4..39d451d1da4a8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10.ts(4,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10.ts (1 errors) ==== - function f() { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js index a0da99f796cde..ca1252825af14 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments10.ts] - function f() { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js index 83d2b735829c8..33c2cb85410de 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments10_ES6.ts] - function f() { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols index 1d9965fa6adc0..ca1cdebf8adca 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 0, 0)) var _arguments = 10; ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 2, 7)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 1, 7)) var a = () => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 3, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 2, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.types index cca819952534e..83bd03cc077f8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10_ES6.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt index 0606a7784b38b..c38c10e2b2433 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11.ts(4,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11.ts (1 errors) ==== - function f(arguments) { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js index 13c1c771c3448..93a808f5775f4 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments11.ts] - function f(arguments) { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js index 9616d2d351c6c..bf67e5e3c8f54 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments11_ES6.ts] - function f(arguments) { var _arguments = 10; var a = () => () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols index a8f9c86c1b212..1af084727bebc 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11_ES6.ts === - function f(arguments) { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 0, 0)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 1, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 0, 11)) var _arguments = 10; ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 2, 7)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 1, 7)) var a = () => () => arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 3, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 2, 7)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.types index 5dddd8fba7ae4..fa19fe7b9b1d0 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11_ES6.ts === - function f(arguments) { >f : (arguments: any) => void >arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt index 4b2dd76a5d0b4..6a8433097b22f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(3,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode. -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(4,23): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(2,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(3,23): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts (2 errors) ==== - class C { f(arguments) { ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js index a2c0b7df48849..5ee0724634785 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments12.ts] - class C { f(arguments) { var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt index 8a3018ceb9c51..c9a21cdb43cab 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12_ES6.ts(3,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12_ES6.ts(2,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12_ES6.ts (1 errors) ==== - class C { f(arguments) { ~~~~~~~~~ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js index 8e7631f6fed2f..566ffa19922db 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments12_ES6.ts] - class C { f(arguments) { var a = () => arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js index ead0a96dacd13..af0cff55d986e 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments13.ts] - function f() { var _arguments = 10; var a = (arguments) => () => _arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols index b46d8ab1a63e9..2db823728f852 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments13.ts, 0, 0)) var _arguments = 10; ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 7)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 1, 7)) var a = (arguments) => () => _arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 13)) ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 13)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 1, 7)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types index 82a027d2dc893..d9bb22d79453c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js index 818d27a1f57e4..5bbe50d44c814 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments13_ES6.ts] - function f() { var _arguments = 10; var a = (arguments) => () => _arguments; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols index 5c4ec4cb687f8..11fbf090e4b5a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols @@ -1,13 +1,12 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 0, 0)) var _arguments = 10; ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 7)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 1, 7)) var a = (arguments) => () => _arguments; ->a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 13)) ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 13)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 1, 7)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types index 59b39a444e109..102ddc0dfaa7c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13_ES6.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt index 8e38cb9d4d3fc..c00b8acb82a34 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14.ts (1 errors) ==== - function f() { if (Math.random()) { const arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js index bd94a2fda9c32..92987b577196c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments14.ts] - function f() { if (Math.random()) { const arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js index cea4589debbf3..0c3b7f4245bd5 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments14_ES6.ts] - function f() { if (Math.random()) { let arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols index fe6788b31f545..af88159a9a40c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 0, 0)) @@ -9,7 +8,7 @@ function f() { >random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) let arguments = 100; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 3, 11)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 2, 11)) return () => arguments; >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.types index df47ed1789082..19526febab37e 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14_ES6.ts === - function f() { >f : () => () => IArguments diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt index 02fb22861c5f4..bbf81e6edfe3c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15.ts(6,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15.ts (1 errors) ==== - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js index bc5f7dca7ee93..a7ece8d0b90fa 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments15.ts] - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js index 0fa3c9d5f6452..50dc52b006a78 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments15_ES6.ts] - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols index 63ee68f0aa744..b87f113f7b289 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 0, 0)) var arguments = "hello"; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 2, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 1, 7)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) @@ -12,7 +11,7 @@ function f() { >random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) const arguments = 100; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 4, 13)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 3, 13)) return () => arguments; >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.types index 558aada282696..69b1e7950717d 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15_ES6.ts === - function f() { >f : () => () => IArguments diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt index 4480e0f570a75..82fa304b73426 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16.ts (1 errors) ==== - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js index 0a87a3c6ac29f..d14304c5e9d14 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments16.ts] - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js index b9aaf7240a7d5..316a509d2badd 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments16_ES6.ts] - function f() { var arguments = "hello"; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols index 6ea3019f1e69c..3cc31438f74fa 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 0, 0)) var arguments = "hello"; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 2, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 6, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 1, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 5, 7)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) @@ -15,5 +14,5 @@ function f() { >arguments : Symbol(arguments) } var arguments = "world"; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 2, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 6, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 1, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 5, 7)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.types index bedbe3dc8b60a..50c619035ac38 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16_ES6.ts === - function f() { >f : () => () => any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt index a54d52e347560..08094932c4518 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17.ts (1 errors) ==== - function f() { var { arguments } = { arguments: "hello" }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js index 8a845ab0cb220..60044ac5dc4d3 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments17.ts] - function f() { var { arguments } = { arguments: "hello" }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js index 1d1a8ece338d0..0bcc93176a808 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments17_ES6.ts] - function f() { var { arguments } = { arguments: "hello" }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols index a7d5e457056d9..ecf7c9ba46ace 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 0, 0)) var { arguments } = { arguments: "hello" }; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 6, 7)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 25)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 1, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 5, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 1, 25)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) @@ -16,5 +15,5 @@ function f() { >arguments : Symbol(arguments) } var arguments = "world"; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 6, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 1, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 5, 7)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.types index 223663bdb1b4e..e0ea34ba0fed6 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17_ES6.ts === - function f() { >f : () => () => any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt index 2595b22801f84..e4278c26824e7 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18.ts (1 errors) ==== - function f() { var { arguments: args } = { arguments }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js index dc40302892bd0..a88a01c7a5636 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments18.ts] - function f() { var { arguments: args } = { arguments }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js index ae9e7e4ef1036..6e8a6a35b2500 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments18_ES6.ts] - function f() { var { arguments: args } = { arguments }; if (Math.random()) { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols index e59ed6b8537c3..a10372c15d84c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 0, 0)) var { arguments: args } = { arguments }; ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 31)) ->args : Symbol(args, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 9)) ->arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 31)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 1, 31)) +>args : Symbol(args, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 1, 9)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 1, 31)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.types index f2fe76e89261c..040eef6748ac9 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18_ES6.ts === - function f() { >f : () => () => IArguments diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt index e6496443e7e42..1db15e807981b 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19.ts(6,33): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. +tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19.ts(5,33): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression. ==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19.ts (1 errors) ==== - function f() { function g() { var _arguments = 10; // No capture in 'g', so no conflict. diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js index 566c0aa49cdaa..95ed86c50475f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments19.ts] - function f() { function g() { var _arguments = 10; // No capture in 'g', so no conflict. diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js index e41aed4f4bff1..80f83c245dc45 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js @@ -1,5 +1,4 @@ //// [emitArrowFunctionWhenUsingArguments19_ES6.ts] - function f() { function g() { var _arguments = 10; // No capture in 'g', so no conflict. diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols index 9e6392daaf18e..05a23a2837711 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols @@ -1,30 +1,29 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19_ES6.ts === - function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 0, 0)) function g() { ->g : Symbol(g, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 1, 14)) +>g : Symbol(g, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 0, 14)) var _arguments = 10; // No capture in 'g', so no conflict. ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 3, 11)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 2, 11)) function h() { ->h : Symbol(h, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 3, 28)) +>h : Symbol(h, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 2, 28)) var capture = () => arguments; // Should trigger an '_arguments' capture into function 'h' ->capture : Symbol(capture, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 5, 15)) +>capture : Symbol(capture, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 4, 15)) >arguments : Symbol(arguments) foo(_arguments); // Error as this does not resolve to the user defined '_arguments' ->foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 8, 5)) ->_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 3, 11)) +>foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 7, 5)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 2, 11)) } } function foo(x: any) { ->foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 8, 5)) ->x : Symbol(x, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 10, 17)) +>foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 7, 5)) +>x : Symbol(x, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 9, 17)) return 100; } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.types index 48d6f2e2935c1..284af00d344f6 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19_ES6.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/emitBOM.js b/tests/baselines/reference/emitBOM.js index f243e715991c7..3f3d61fd2f9a5 100644 --- a/tests/baselines/reference/emitBOM.js +++ b/tests/baselines/reference/emitBOM.js @@ -1,5 +1,4 @@ //// [emitBOM.ts] - // JS and d.ts output should have a BOM but not the sourcemap var x; diff --git a/tests/baselines/reference/emitBOM.js.map b/tests/baselines/reference/emitBOM.js.map index 69ccb88429509..d7a2f8d978010 100644 --- a/tests/baselines/reference/emitBOM.js.map +++ b/tests/baselines/reference/emitBOM.js.map @@ -1,2 +1,2 @@ //// [emitBOM.js.map] -{"version":3,"file":"emitBOM.js","sourceRoot":"","sources":["emitBOM.ts"],"names":[],"mappings":"AACA,6DAA6D;AAC7D,IAAI,CAAC,CAAC"} \ No newline at end of file +{"version":3,"file":"emitBOM.js","sourceRoot":"","sources":["emitBOM.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,IAAI,CAAC,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/emitBOM.sourcemap.txt b/tests/baselines/reference/emitBOM.sourcemap.txt index 4cf35c4d1e39c..c88be299a740f 100644 --- a/tests/baselines/reference/emitBOM.sourcemap.txt +++ b/tests/baselines/reference/emitBOM.sourcemap.txt @@ -11,11 +11,10 @@ sourceFile:emitBOM.ts >>>// JS and d.ts output should have a BOM but not the sourcemap 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -1 > - > +1 > 2 >// JS and d.ts output should have a BOM but not the sourcemap -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 62) Source(2, 62) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 62) Source(1, 62) + SourceIndex(0) --- >>>var x; 1 > @@ -28,9 +27,9 @@ sourceFile:emitBOM.ts 2 >var 3 > x 4 > ; -1 >Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(2, 6) Source(3, 6) + SourceIndex(0) -4 >Emitted(2, 7) Source(3, 7) + SourceIndex(0) +1 >Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(2, 6) Source(2, 6) + SourceIndex(0) +4 >Emitted(2, 7) Source(2, 7) + SourceIndex(0) --- >>>//# sourceMappingURL=emitBOM.js.map \ No newline at end of file diff --git a/tests/baselines/reference/emitBOM.symbols b/tests/baselines/reference/emitBOM.symbols index 85f495580d7e6..ab23b04908013 100644 --- a/tests/baselines/reference/emitBOM.symbols +++ b/tests/baselines/reference/emitBOM.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/emitBOM.ts === - // JS and d.ts output should have a BOM but not the sourcemap var x; ->x : Symbol(x, Decl(emitBOM.ts, 2, 3)) +>x : Symbol(x, Decl(emitBOM.ts, 1, 3)) diff --git a/tests/baselines/reference/emitBOM.types b/tests/baselines/reference/emitBOM.types index b38fd19c8f4af..0991acbac6f22 100644 --- a/tests/baselines/reference/emitBOM.types +++ b/tests/baselines/reference/emitBOM.types @@ -1,5 +1,4 @@ === tests/cases/compiler/emitBOM.ts === - // JS and d.ts output should have a BOM but not the sourcemap var x; >x : any diff --git a/tests/baselines/reference/emitBundleWithPrologueDirectives1.js b/tests/baselines/reference/emitBundleWithPrologueDirectives1.js new file mode 100644 index 0000000000000..07214800aa8fc --- /dev/null +++ b/tests/baselines/reference/emitBundleWithPrologueDirectives1.js @@ -0,0 +1,37 @@ +//// [test.ts] +/* Detached Comment */ + +// Class Doo Comment +export class Doo {} +class Scooby extends Doo {} + +//// [outFile.js] +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +/* Detached Comment */ +define("test", ["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + // Class Doo Comment + var Doo = (function () { + function Doo() { + } + return Doo; + }()); + exports.Doo = Doo; + var Scooby = (function (_super) { + __extends(Scooby, _super); + function Scooby() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scooby; + }(Doo)); +}); diff --git a/tests/baselines/reference/emitBundleWithPrologueDirectives1.symbols b/tests/baselines/reference/emitBundleWithPrologueDirectives1.symbols new file mode 100644 index 0000000000000..f9e0dea427dec --- /dev/null +++ b/tests/baselines/reference/emitBundleWithPrologueDirectives1.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/test.ts === +/* Detached Comment */ + +// Class Doo Comment +export class Doo {} +>Doo : Symbol(Doo, Decl(test.ts, 0, 0)) + +class Scooby extends Doo {} +>Scooby : Symbol(Scooby, Decl(test.ts, 3, 19)) +>Doo : Symbol(Doo, Decl(test.ts, 0, 0)) + diff --git a/tests/baselines/reference/emitBundleWithPrologueDirectives1.types b/tests/baselines/reference/emitBundleWithPrologueDirectives1.types new file mode 100644 index 0000000000000..8eede161c798c --- /dev/null +++ b/tests/baselines/reference/emitBundleWithPrologueDirectives1.types @@ -0,0 +1,11 @@ +=== tests/cases/compiler/test.ts === +/* Detached Comment */ + +// Class Doo Comment +export class Doo {} +>Doo : Doo + +class Scooby extends Doo {} +>Scooby : Scooby +>Doo : Doo + diff --git a/tests/baselines/reference/emitBundleWithShebang1.js b/tests/baselines/reference/emitBundleWithShebang1.js new file mode 100644 index 0000000000000..1c7b2140eb5c0 --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang1.js @@ -0,0 +1,29 @@ +//// [emitBundleWithShebang1.ts] +#!/usr/bin/env gjs +class Doo {} +class Scooby extends Doo {} + +//// [outFile.js] +#!/usr/bin/env gjs +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var Doo = (function () { + function Doo() { + } + return Doo; +}()); +var Scooby = (function (_super) { + __extends(Scooby, _super); + function Scooby() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scooby; +}(Doo)); diff --git a/tests/baselines/reference/emitBundleWithShebang1.symbols b/tests/baselines/reference/emitBundleWithShebang1.symbols new file mode 100644 index 0000000000000..9763f6383cdbd --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang1.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/emitBundleWithShebang1.ts === +#!/usr/bin/env gjs +class Doo {} +>Doo : Symbol(Doo, Decl(emitBundleWithShebang1.ts, 0, 0)) + +class Scooby extends Doo {} +>Scooby : Symbol(Scooby, Decl(emitBundleWithShebang1.ts, 1, 12)) +>Doo : Symbol(Doo, Decl(emitBundleWithShebang1.ts, 0, 0)) + diff --git a/tests/baselines/reference/emitBundleWithShebang1.types b/tests/baselines/reference/emitBundleWithShebang1.types new file mode 100644 index 0000000000000..b3c69986530e6 --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang1.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/emitBundleWithShebang1.ts === +#!/usr/bin/env gjs +class Doo {} +>Doo : Doo + +class Scooby extends Doo {} +>Scooby : Scooby +>Doo : Doo + diff --git a/tests/baselines/reference/emitBundleWithShebang2.js b/tests/baselines/reference/emitBundleWithShebang2.js new file mode 100644 index 0000000000000..b5d3d34641aca --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang2.js @@ -0,0 +1,48 @@ +//// [tests/cases/compiler/emitBundleWithShebang2.ts] //// + +//// [test.ts] +#!/usr/bin/env gjs +class Doo {} +class Scooby extends Doo {} + +//// [test2.ts] +#!/usr/bin/env js +class Dood {} +class Scoobyd extends Dood {} + +//// [outFile.js] +#!/usr/bin/env gjs +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var Doo = (function () { + function Doo() { + } + return Doo; +}()); +var Scooby = (function (_super) { + __extends(Scooby, _super); + function Scooby() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scooby; +}(Doo)); +var Dood = (function () { + function Dood() { + } + return Dood; +}()); +var Scoobyd = (function (_super) { + __extends(Scoobyd, _super); + function Scoobyd() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scoobyd; +}(Dood)); diff --git a/tests/baselines/reference/emitBundleWithShebang2.symbols b/tests/baselines/reference/emitBundleWithShebang2.symbols new file mode 100644 index 0000000000000..effe73f3aef80 --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang2.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/test.ts === +#!/usr/bin/env gjs +class Doo {} +>Doo : Symbol(Doo, Decl(test.ts, 0, 0)) + +class Scooby extends Doo {} +>Scooby : Symbol(Scooby, Decl(test.ts, 1, 12)) +>Doo : Symbol(Doo, Decl(test.ts, 0, 0)) + +=== tests/cases/compiler/test2.ts === +#!/usr/bin/env js +class Dood {} +>Dood : Symbol(Dood, Decl(test2.ts, 0, 0)) + +class Scoobyd extends Dood {} +>Scoobyd : Symbol(Scoobyd, Decl(test2.ts, 1, 13)) +>Dood : Symbol(Dood, Decl(test2.ts, 0, 0)) + diff --git a/tests/baselines/reference/emitBundleWithShebang2.types b/tests/baselines/reference/emitBundleWithShebang2.types new file mode 100644 index 0000000000000..6310cd484069c --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebang2.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/test.ts === +#!/usr/bin/env gjs +class Doo {} +>Doo : Doo + +class Scooby extends Doo {} +>Scooby : Scooby +>Doo : Doo + +=== tests/cases/compiler/test2.ts === +#!/usr/bin/env js +class Dood {} +>Dood : Dood + +class Scoobyd extends Dood {} +>Scoobyd : Scoobyd +>Dood : Dood + diff --git a/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives1.js b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives1.js new file mode 100644 index 0000000000000..03b6c4a79f91f --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives1.js @@ -0,0 +1,31 @@ +//// [test.ts] +#!/usr/bin/env gjs +"use strict" +class Doo {} +class Scooby extends Doo {} + +//// [outFile.js] +#!/usr/bin/env gjs +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var Doo = (function () { + function Doo() { + } + return Doo; +}()); +var Scooby = (function (_super) { + __extends(Scooby, _super); + function Scooby() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scooby; +}(Doo)); diff --git a/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives1.symbols b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives1.symbols new file mode 100644 index 0000000000000..3da4cfdbac0ba --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives1.symbols @@ -0,0 +1,10 @@ +=== tests/cases/compiler/test.ts === +#!/usr/bin/env gjs +"use strict" +class Doo {} +>Doo : Symbol(Doo, Decl(test.ts, 1, 12)) + +class Scooby extends Doo {} +>Scooby : Symbol(Scooby, Decl(test.ts, 2, 12)) +>Doo : Symbol(Doo, Decl(test.ts, 1, 12)) + diff --git a/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives1.types b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives1.types new file mode 100644 index 0000000000000..c1f6379c2940b --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives1.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/test.ts === +#!/usr/bin/env gjs +"use strict" +>"use strict" : "use strict" + +class Doo {} +>Doo : Doo + +class Scooby extends Doo {} +>Scooby : Scooby +>Doo : Doo + diff --git a/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives2.js b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives2.js new file mode 100644 index 0000000000000..e469c526779d3 --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives2.js @@ -0,0 +1,53 @@ +//// [tests/cases/compiler/emitBundleWithShebangAndPrologueDirectives2.ts] //// + +//// [test.ts] +#!/usr/bin/env gjs +"use strict" +class Doo {} +class Scooby extends Doo {} + +//// [test1.ts] +#!/usr/bin/env gjs +"use strict" +"Another prologue" +class Dood {} +class Scoobyd extends Dood {} + +//// [outFile.js] +#!/usr/bin/env gjs +"use strict"; +"Another prologue"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var Doo = (function () { + function Doo() { + } + return Doo; +}()); +var Scooby = (function (_super) { + __extends(Scooby, _super); + function Scooby() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scooby; +}(Doo)); +var Dood = (function () { + function Dood() { + } + return Dood; +}()); +var Scoobyd = (function (_super) { + __extends(Scoobyd, _super); + function Scoobyd() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Scoobyd; +}(Dood)); diff --git a/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives2.symbols b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives2.symbols new file mode 100644 index 0000000000000..48f90e09b93fa --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives2.symbols @@ -0,0 +1,21 @@ +=== tests/cases/compiler/test.ts === +#!/usr/bin/env gjs +"use strict" +class Doo {} +>Doo : Symbol(Doo, Decl(test.ts, 1, 12)) + +class Scooby extends Doo {} +>Scooby : Symbol(Scooby, Decl(test.ts, 2, 12)) +>Doo : Symbol(Doo, Decl(test.ts, 1, 12)) + +=== tests/cases/compiler/test1.ts === +#!/usr/bin/env gjs +"use strict" +"Another prologue" +class Dood {} +>Dood : Symbol(Dood, Decl(test1.ts, 2, 18)) + +class Scoobyd extends Dood {} +>Scoobyd : Symbol(Scoobyd, Decl(test1.ts, 3, 13)) +>Dood : Symbol(Dood, Decl(test1.ts, 2, 18)) + diff --git a/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives2.types b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives2.types new file mode 100644 index 0000000000000..2884e5958e8cb --- /dev/null +++ b/tests/baselines/reference/emitBundleWithShebangAndPrologueDirectives2.types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/test.ts === +#!/usr/bin/env gjs +"use strict" +>"use strict" : "use strict" + +class Doo {} +>Doo : Doo + +class Scooby extends Doo {} +>Scooby : Scooby +>Doo : Doo + +=== tests/cases/compiler/test1.ts === +#!/usr/bin/env gjs +"use strict" +>"use strict" : "use strict" + +"Another prologue" +>"Another prologue" : "Another prologue" + +class Dood {} +>Dood : Dood + +class Scoobyd extends Dood {} +>Scoobyd : Scoobyd +>Dood : Dood + diff --git a/tests/baselines/reference/emitClassDeclarationWithPropertyAccessInHeritageClause1.js b/tests/baselines/reference/emitClassDeclarationWithPropertyAccessInHeritageClause1.js new file mode 100644 index 0000000000000..817a03f974aa7 --- /dev/null +++ b/tests/baselines/reference/emitClassDeclarationWithPropertyAccessInHeritageClause1.js @@ -0,0 +1,33 @@ +//// [emitClassDeclarationWithPropertyAccessInHeritageClause1.ts] +class B {} +function foo() { + return {B: B}; +} +class C extends (foo()).B {} + +//// [emitClassDeclarationWithPropertyAccessInHeritageClause1.js] +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var B = (function () { + function B() { + } + return B; +}()); +function foo() { + return { B: B }; +} +var C = (function (_super) { + __extends(C, _super); + function C() { + return _super !== null && _super.apply(this, arguments) || this; + } + return C; +}((foo()).B)); diff --git a/tests/baselines/reference/emitClassDeclarationWithPropertyAccessInHeritageClause1.symbols b/tests/baselines/reference/emitClassDeclarationWithPropertyAccessInHeritageClause1.symbols new file mode 100644 index 0000000000000..d2c5d24a7bc04 --- /dev/null +++ b/tests/baselines/reference/emitClassDeclarationWithPropertyAccessInHeritageClause1.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithPropertyAccessInHeritageClause1.ts === +class B {} +>B : Symbol(B, Decl(emitClassDeclarationWithPropertyAccessInHeritageClause1.ts, 0, 0)) + +function foo() { +>foo : Symbol(foo, Decl(emitClassDeclarationWithPropertyAccessInHeritageClause1.ts, 0, 10)) + + return {B: B}; +>B : Symbol(B, Decl(emitClassDeclarationWithPropertyAccessInHeritageClause1.ts, 2, 12)) +>B : Symbol(B, Decl(emitClassDeclarationWithPropertyAccessInHeritageClause1.ts, 0, 0)) +} +class C extends (foo()).B {} +>C : Symbol(C, Decl(emitClassDeclarationWithPropertyAccessInHeritageClause1.ts, 3, 1)) +>(foo()).B : Symbol(B, Decl(emitClassDeclarationWithPropertyAccessInHeritageClause1.ts, 2, 12)) +>foo : Symbol(foo, Decl(emitClassDeclarationWithPropertyAccessInHeritageClause1.ts, 0, 10)) +>B : Symbol(B, Decl(emitClassDeclarationWithPropertyAccessInHeritageClause1.ts, 2, 12)) + diff --git a/tests/baselines/reference/emitClassDeclarationWithPropertyAccessInHeritageClause1.types b/tests/baselines/reference/emitClassDeclarationWithPropertyAccessInHeritageClause1.types new file mode 100644 index 0000000000000..c91fae28c7e24 --- /dev/null +++ b/tests/baselines/reference/emitClassDeclarationWithPropertyAccessInHeritageClause1.types @@ -0,0 +1,20 @@ +=== tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithPropertyAccessInHeritageClause1.ts === +class B {} +>B : B + +function foo() { +>foo : () => { B: typeof B; } + + return {B: B}; +>{B: B} : { B: typeof B; } +>B : typeof B +>B : typeof B +} +class C extends (foo()).B {} +>C : C +>(foo()).B : B +>(foo()) : { B: typeof B; } +>foo() : { B: typeof B; } +>foo : () => { B: typeof B; } +>B : typeof B + diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js index 77b9173015664..16c946c3e87ef 100644 --- a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js +++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js @@ -1,5 +1,4 @@ //// [emitClassDeclarationWithSuperMethodCall01.ts] - class Parent { foo() { } diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols index dc749161623eb..27402b95aded9 100644 --- a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols +++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols @@ -1,24 +1,23 @@ === tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithSuperMethodCall01.ts === - class Parent { >Parent : Symbol(Parent, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 0)) foo() { ->foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14)) +>foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 14)) } } class Foo extends Parent { ->Foo : Symbol(Foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 4, 1)) +>Foo : Symbol(Foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 3, 1)) >Parent : Symbol(Parent, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 0)) foo() { ->foo : Symbol(Foo.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 6, 26)) +>foo : Symbol(Foo.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 5, 26)) var x = () => super.foo(); ->x : Symbol(x, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 8, 11)) ->super.foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14)) +>x : Symbol(x, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 7, 11)) +>super.foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 14)) >super : Symbol(Parent, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 0)) ->foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14)) +>foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 14)) } } diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types index 8b68af897acfa..63d5d3a07ad47 100644 --- a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types +++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithSuperMethodCall01.ts === - class Parent { >Parent : Parent diff --git a/tests/baselines/reference/emitCommentsOnlyFile.js b/tests/baselines/reference/emitCommentsOnlyFile.js index d720dc3c1915c..23dddfa4849a5 100644 --- a/tests/baselines/reference/emitCommentsOnlyFile.js +++ b/tests/baselines/reference/emitCommentsOnlyFile.js @@ -1,5 +1,4 @@ //// [emitCommentsOnlyFile.ts] - /** * @name Foo * @class diff --git a/tests/baselines/reference/emitCommentsOnlyFile.symbols b/tests/baselines/reference/emitCommentsOnlyFile.symbols index 38b23eb128d56..04e8f4a103a12 100644 --- a/tests/baselines/reference/emitCommentsOnlyFile.symbols +++ b/tests/baselines/reference/emitCommentsOnlyFile.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/emitCommentsOnlyFile.ts === - -No type information for this code./** +/** No type information for this code.* @name Foo No type information for this code.* @class No type information for this code.*/ diff --git a/tests/baselines/reference/emitCommentsOnlyFile.types b/tests/baselines/reference/emitCommentsOnlyFile.types index 38b23eb128d56..04e8f4a103a12 100644 --- a/tests/baselines/reference/emitCommentsOnlyFile.types +++ b/tests/baselines/reference/emitCommentsOnlyFile.types @@ -1,6 +1,5 @@ === tests/cases/compiler/emitCommentsOnlyFile.ts === - -No type information for this code./** +/** No type information for this code.* @name Foo No type information for this code.* @class No type information for this code.*/ diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js index d94104a1c4b32..050e36140dee4 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts] - var array0 = [1, 2, 3] var i0 = 0; array0[++i0] **= 2; diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols index 83f71871ec016..27174348d1a9e 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols @@ -1,51 +1,50 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts === - var array0 = [1, 2, 3] ->array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3)) +>array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 0, 3)) var i0 = 0; ->i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 2, 3)) +>i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3)) array0[++i0] **= 2; ->array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3)) ->i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 2, 3)) +>array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 0, 3)) +>i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3)) var array1 = [1, 2, 3] ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 4, 3)) var i1 = 0; ->i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 6, 3)) +>i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) array1[++i1] **= array1[++i1] **= 2; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) ->i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 6, 3)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) ->i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 6, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 4, 3)) +>i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 4, 3)) +>i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3)) var array2 = [1, 2, 3] ->array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) +>array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 8, 3)) var i2 = 0; ->i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 10, 3)) +>i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) array2[++i2] **= array2[++i2] ** 2; ->array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) ->i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 10, 3)) ->array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) ->i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 10, 3)) +>array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 8, 3)) +>i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) +>array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 8, 3)) +>i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3)) var array3 = [2, 2, 3]; ->array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) +>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 12, 3)) var j0 = 0, j1 = 1; ->j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 3)) ->j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 11)) +>j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) +>j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 11)) array3[j0++] **= array3[j1++] **= array3[j0++] **= 1; ->array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) ->j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 3)) ->array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) ->j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 11)) ->array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) ->j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 3)) +>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 12, 3)) +>j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) +>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 12, 3)) +>j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 11)) +>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 12, 3)) +>j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3)) diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types index ddb10cc9447f9..96ed4dfde4c12 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts === - var array0 = [1, 2, 3] >array0 : number[] >[1, 2, 3] : number[] diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js index 66b9a7018fcc6..0410f77ad0c6e 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts] - var object = { _0: 2, get 0() { diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols index dbd5aa150dc5e..ac738dbf47734 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols @@ -1,37 +1,36 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts === - var object = { ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) _0: 2, ->_0 : Symbol(_0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 14)) +>_0 : Symbol(_0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 14)) get 0() { return this._0; }, set 0(x: number) { ->x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 6, 10)) +>x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 10)) this._0 = x; ->x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 6, 10)) +>x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 10)) }, } object[0] **= object[0]; ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) object[0] **= object[0] **= 2; ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) object[0] **= object[0] ** 2; ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) ->object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3)) ->0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) +>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 0, 3)) +>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 4, 6)) diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types index 32e5b33e41132..0dfd96393c9f8 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts === - var object = { >object : { _0: number; 0: number; } >{ _0: 2, get 0() { return this._0; }, set 0(x: number) { this._0 = x; },} : { _0: number; 0: number; } diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js index d16e20c4cac21..4ba9cff676d92 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts] - var globalCounter = 0; function incrementIdx(max: number) { globalCounter += 1; diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols index 19a9805a0c2f5..19ebc05016396 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols @@ -1,60 +1,59 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts === - var globalCounter = 0; ->globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 3)) +>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 3)) function incrementIdx(max: number) { ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) ->max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 2, 22)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) +>max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) globalCounter += 1; ->globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 3)) +>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 3)) let idx = Math.floor(Math.random() * max); ->idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 4, 7)) +>idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 3, 7)) >Math.floor : Symbol(Math.floor, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >floor : Symbol(Math.floor, Decl(lib.d.ts, --, --)) >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) ->max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 2, 22)) +>max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) return idx; ->idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 4, 7)) +>idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 3, 7)) } var array1 = [1, 2, 3, 4, 5]; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) array1[incrementIdx(array1.length)] **= 3; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] **= 2; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] ** 2; ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) ->incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) +>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 0, 22)) >array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3)) +>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 7, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types index fec095dc6964e..c7488bb9bd2ce 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts === - var globalCounter = 0; >globalCounter : number >0 : 0 diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js index c6244161b19f1..90255262e6082 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts] - var globalCounter = 0; function foo() { globalCounter += 1; diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols index 6bdf5f331fb33..2d7fb477b10c0 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols @@ -1,59 +1,58 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts === - var globalCounter = 0; ->globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 3)) +>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 3)) function foo() { ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) globalCounter += 1; ->globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 3)) +>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 3)) return { prop: 2 }; ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) } foo().prop **= 2; ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) var result0 = foo().prop **= 2; ->result0 : Symbol(result0, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 7, 3)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>result0 : Symbol(result0, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 6, 3)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) foo().prop **= foo().prop **= 2; ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) var result1 = foo().prop **= foo().prop **= 2; ->result1 : Symbol(result1, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 9, 3)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>result1 : Symbol(result1, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 8, 3)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) foo().prop **= foo().prop ** 2; ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) var result2 = foo().prop **= foo().prop ** 2; ->result2 : Symbol(result2, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 11, 3)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) ->foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22)) ->prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12)) +>result2 : Symbol(result2, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 10, 3)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) +>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 0, 22)) +>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 3, 12)) diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types index 1a8a29bae9b2b..b4841f76cfff9 100644 --- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types +++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts === - var globalCounter = 0; >globalCounter : number >0 : 0 diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator1.js b/tests/baselines/reference/emitCompoundExponentiationOperator1.js index cf72ce1d39f5c..79580f02f9f4b 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator1.js +++ b/tests/baselines/reference/emitCompoundExponentiationOperator1.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationOperator1.ts] - var comp: number; comp **= 1; diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols b/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols index a6a57c6fb8843..e712bc8def412 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols @@ -1,83 +1,82 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts === - var comp: number; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= 1; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp ** 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp + 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp - 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp * 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp / 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** comp % 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp - 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp + 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp * 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp / 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= (comp % 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 + 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 - 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 * 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 / 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) comp **= comp ** (5 % 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 0, 3)) diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator1.types b/tests/baselines/reference/emitCompoundExponentiationOperator1.types index 6a4a5b5bab92f..55dde21b8fe4b 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator1.types +++ b/tests/baselines/reference/emitCompoundExponentiationOperator1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts === - var comp: number; >comp : number diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator2.js b/tests/baselines/reference/emitCompoundExponentiationOperator2.js index 91b988423ac86..1f2a475cea066 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator2.js +++ b/tests/baselines/reference/emitCompoundExponentiationOperator2.js @@ -1,5 +1,4 @@ //// [emitCompoundExponentiationOperator2.ts] - var comp: number; comp **= 1; diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols b/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols index 04a22b2782cf4..d510c2fe9ae06 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols +++ b/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols @@ -1,76 +1,75 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator2.ts === - var comp: number; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= 1; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 + 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 - 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 * 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 / 2; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 + 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 - 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 * 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 / 2); ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 + 2 ** 3; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 - 2 ** 4; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 * 2 ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= 1 / 2 ** 6; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 + 2) ** 3; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 - 2) ** 4; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 * 2) ** 5; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) comp **= comp **= (1 / 2) ** 6; ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) ->comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) +>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 0, 3)) diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator2.types b/tests/baselines/reference/emitCompoundExponentiationOperator2.types index f715a9593f204..948ad6d3e5d9c 100644 --- a/tests/baselines/reference/emitCompoundExponentiationOperator2.types +++ b/tests/baselines/reference/emitCompoundExponentiationOperator2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator2.ts === - var comp: number; >comp : number diff --git a/tests/baselines/reference/emitDecoratorMetadata_restArgs.js b/tests/baselines/reference/emitDecoratorMetadata_restArgs.js index 4bc1f02321296..862a1baa02535 100644 --- a/tests/baselines/reference/emitDecoratorMetadata_restArgs.js +++ b/tests/baselines/reference/emitDecoratorMetadata_restArgs.js @@ -1,5 +1,4 @@ //// [emitDecoratorMetadata_restArgs.ts] - declare const MyClassDecorator: ClassDecorator; declare const MyMethodDecorator: MethodDecorator; diff --git a/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols b/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols index 29ccb8b2711d2..c37ca0b8e4df6 100644 --- a/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols +++ b/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols @@ -1,45 +1,44 @@ === tests/cases/compiler/emitDecoratorMetadata_restArgs.ts === - declare const MyClassDecorator: ClassDecorator; ->MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) +>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 0, 13)) >ClassDecorator : Symbol(ClassDecorator, Decl(lib.d.ts, --, --)) declare const MyMethodDecorator: MethodDecorator; ->MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13)) +>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) >MethodDecorator : Symbol(MethodDecorator, Decl(lib.d.ts, --, --)) @MyClassDecorator ->MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) +>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 0, 13)) class A { ->A : Symbol(A, Decl(emitDecoratorMetadata_restArgs.ts, 2, 49)) +>A : Symbol(A, Decl(emitDecoratorMetadata_restArgs.ts, 1, 49)) constructor(...args) {} ->args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 6, 16)) +>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 5, 16)) @MyMethodDecorator ->MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13)) +>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) method(...args) {} ->method : Symbol(A.method, Decl(emitDecoratorMetadata_restArgs.ts, 6, 27)) ->args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 8, 11)) +>method : Symbol(A.method, Decl(emitDecoratorMetadata_restArgs.ts, 5, 27)) +>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 7, 11)) } @MyClassDecorator ->MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) +>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 0, 13)) class B { ->B : Symbol(B, Decl(emitDecoratorMetadata_restArgs.ts, 9, 1)) +>B : Symbol(B, Decl(emitDecoratorMetadata_restArgs.ts, 8, 1)) constructor(...args: number[]) {} ->args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 13, 16)) +>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 12, 16)) @MyMethodDecorator ->MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13)) +>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13)) method(this: this, ...args: string[]) {} ->method : Symbol(B.method, Decl(emitDecoratorMetadata_restArgs.ts, 13, 37)) ->this : Symbol(this, Decl(emitDecoratorMetadata_restArgs.ts, 15, 11)) ->args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 15, 22)) +>method : Symbol(B.method, Decl(emitDecoratorMetadata_restArgs.ts, 12, 37)) +>this : Symbol(this, Decl(emitDecoratorMetadata_restArgs.ts, 14, 11)) +>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 14, 22)) } diff --git a/tests/baselines/reference/emitDecoratorMetadata_restArgs.types b/tests/baselines/reference/emitDecoratorMetadata_restArgs.types index 8161634a092a4..5fc9a7b0ed030 100644 --- a/tests/baselines/reference/emitDecoratorMetadata_restArgs.types +++ b/tests/baselines/reference/emitDecoratorMetadata_restArgs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/emitDecoratorMetadata_restArgs.ts === - declare const MyClassDecorator: ClassDecorator; >MyClassDecorator : ClassDecorator >ClassDecorator : ClassDecorator diff --git a/tests/baselines/reference/emitExponentiationOperator1.js b/tests/baselines/reference/emitExponentiationOperator1.js index 2b270ef708b6d..00baa9e1b87ca 100644 --- a/tests/baselines/reference/emitExponentiationOperator1.js +++ b/tests/baselines/reference/emitExponentiationOperator1.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperator1.ts] - 1 ** -2; 1 ** 2; (-1) ** 2 diff --git a/tests/baselines/reference/emitExponentiationOperator1.symbols b/tests/baselines/reference/emitExponentiationOperator1.symbols index 5fb3419d41903..9a86abe3f9a22 100644 --- a/tests/baselines/reference/emitExponentiationOperator1.symbols +++ b/tests/baselines/reference/emitExponentiationOperator1.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts === - -No type information for this code.1 ** -2; +1 ** -2; No type information for this code.1 ** 2; No type information for this code.(-1) ** 2 No type information for this code.1 ** 2 ** 3; diff --git a/tests/baselines/reference/emitExponentiationOperator1.types b/tests/baselines/reference/emitExponentiationOperator1.types index 9db01d34f2267..34ccbec9e26b5 100644 --- a/tests/baselines/reference/emitExponentiationOperator1.types +++ b/tests/baselines/reference/emitExponentiationOperator1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts === - 1 ** -2; >1 ** -2 : number >1 : 1 diff --git a/tests/baselines/reference/emitExponentiationOperator2.js b/tests/baselines/reference/emitExponentiationOperator2.js index 46f80b44bba4c..9eee0c3a24693 100644 --- a/tests/baselines/reference/emitExponentiationOperator2.js +++ b/tests/baselines/reference/emitExponentiationOperator2.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperator2.ts] - var temp = 10; ++temp ** 3; diff --git a/tests/baselines/reference/emitExponentiationOperator2.symbols b/tests/baselines/reference/emitExponentiationOperator2.symbols index c3d9e4b25df82..25303debc655e 100644 --- a/tests/baselines/reference/emitExponentiationOperator2.symbols +++ b/tests/baselines/reference/emitExponentiationOperator2.symbols @@ -1,152 +1,151 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts === - var temp = 10; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp++ ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp + temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp - temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp * temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp / temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp % temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp++ ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- ** -temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp++ ** +temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- + temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- - temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- * temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- / temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) temp-- % temp ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp + 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp - 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp * 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp / 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) --temp % 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp + 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp - 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp * 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) ++temp / 2 ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** temp++; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** temp--; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** temp++ ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** temp-- ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp + 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp - 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp * 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp / 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** ++temp % 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp + 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp - 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp * 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp / 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) 3 ** --temp % 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperator2.types b/tests/baselines/reference/emitExponentiationOperator2.types index b2936f6acef64..288aafc0f8926 100644 --- a/tests/baselines/reference/emitExponentiationOperator2.types +++ b/tests/baselines/reference/emitExponentiationOperator2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts === - var temp = 10; >temp : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperator3.js b/tests/baselines/reference/emitExponentiationOperator3.js index ceb08c868dbcf..cff2b2685b13b 100644 --- a/tests/baselines/reference/emitExponentiationOperator3.js +++ b/tests/baselines/reference/emitExponentiationOperator3.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperator3.ts] - var temp = 10; (-++temp) ** 3; diff --git a/tests/baselines/reference/emitExponentiationOperator3.symbols b/tests/baselines/reference/emitExponentiationOperator3.symbols index 231117438551c..70adf2b1565a4 100644 --- a/tests/baselines/reference/emitExponentiationOperator3.symbols +++ b/tests/baselines/reference/emitExponentiationOperator3.symbols @@ -1,107 +1,106 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator3.ts === - var temp = 10; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-++temp) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+--temp) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-temp++) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+temp--) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-(1 ** ++temp)) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-(1 ** --temp)) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-(1 ** temp++)) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-(1 ** temp--)) ** 3; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** temp++; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** temp--; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** ++temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** --temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** temp++; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** temp--; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** ++temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** --temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** temp++ ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** temp-- ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** ++temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (-3) ** --temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** temp++ ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** temp-- ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** ++temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) (+3) ** --temp ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** -temp++; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** -temp--; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** -++temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** +--temp; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (-temp++) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (-temp--) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (+temp++) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (+temp--) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (-++temp) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) 3 ** (+--temp) ** 2; ->temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3)) +>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperator3.types b/tests/baselines/reference/emitExponentiationOperator3.types index 38bb5a0895c56..2fe95d4db8f5d 100644 --- a/tests/baselines/reference/emitExponentiationOperator3.types +++ b/tests/baselines/reference/emitExponentiationOperator3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator3.ts === - var temp = 10; >temp : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js index c3c589e6a6154..379af45e0f7c4 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTempalteString4.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols index 7892323ef1d0f..c9f708f317e27 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols @@ -1,114 +1,113 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) // With TemplateTail `${t1 ** -t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) `${(-t1) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(-++t1) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(-t1++) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(~t1) ** t2 ** --t1 } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) // TempateHead & TemplateTail are empt `${t1 ** -t2} hello world ${t1 ** -t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) `${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) ** - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) // With templateHead `hello ${(-t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `hello ${(-++t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `hello ${(-t1++) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `hello ${(~t1) ** t2 ** --t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types index d11846227f2e1..08bb88d696536 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js index bda3f8be251a9..2bc249a86a4dc 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTempalteString4ES6.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols index 1f4cd74502ba0..1e5528b695f82 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols @@ -1,114 +1,113 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4ES6.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) // With TemplateTail `${t1 ** -t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) `${(-t1) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(-++t1) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(-t1++) ** t2 - t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(~t1) ** t2 ** --t1 } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) // TempateHead & TemplateTail are empt `${t1 ** -t2} hello world ${t1 ** -t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) `${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) ** - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) // With templateHead `hello ${(-t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `hello ${(-++t1) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `hello ${(-t1++) ** t2 - t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `hello ${(~t1) ** t2 ** --t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types index 610c3a64a6ed2..0918c28892aad 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4ES6.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js index cd9ac32bbd2d5..dbfd59871561d 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString1.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols index 8830135987eaf..a79786f94b0d5 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) // TempateHead & TemplateTail are empty `${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) `${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t2 + t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${1 + typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2}${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) `${t1 ** t2 ** t1}${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t1}${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2 + t1}${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2} hello world ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) `${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types index 4f78cd61fcc20..326c947735b2e 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js index d32caf4510644..2d3623b30c988 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString1ES6.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols index 7b07fa26bba13..89e5f039bc19a 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1ES6.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) // TempateHead & TemplateTail are empty `${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) `${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${1 + typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2}${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) `${t1 ** t2 ** t1}${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t1}${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2 + t1}${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2} hello world ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) `${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types index 0bc65c31b1255..2aa89e26587cc 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1ES6.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js index cd73e04327f03..93604d0e00fb3 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString2.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols index 224499c12894f..d704826755698 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) // With templateHead `hello ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) `hello ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${1 + typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2}${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) `hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2} hello world ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) `hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types index 9b77f4bc3fccd..c7e861e8a3925 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js index ac92b4598aa2f..5263bb8e42004 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString2ES6.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols index fd674b21d330a..045f232e869f2 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2ES6.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) // With templateHead `hello ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) `hello ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1 }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${1 + typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2}${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) `hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2} hello world ${t1 ** t2}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) `hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) `hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types index ed0be973e5b80..31c845f91b8aa 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2ES6.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js index 966464b82207a..93333a3a8df2d 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString3.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols index 758a0e2956be6..7d4dd49c3943b 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) // With TemplateTail `${t1 ** t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) `${t1 ** t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t2 + t1 } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${1 + typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2}${t1 ** t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) `${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t1}${t1 + t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2 + t1}${t1 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2} hello world ${t1 ** t2} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) `${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types index 16fe31dde5edc..6e0dea6b9dc75 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js index ec037dd2150b0..b5f0e48677f17 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js @@ -1,5 +1,4 @@ //// [emitExponentiationOperatorInTemplateString3ES6.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols index a6062348432a1..4192ac635dce5 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols @@ -1,143 +1,142 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3ES6.ts === - var t1 = 10; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) var t2 = 10; ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) var s; ->s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 3, 3)) +>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) // With TemplateTail `${t1 ** t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) `${t1 ** t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1 } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${1 + typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2}${t1 ** t2} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) `${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t1}${t1 + t2 ** t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2 + t1}${t1 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2} hello world ${t1 ** t2} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) `${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) `${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`; ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) ->t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3)) ->t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) +>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3)) +>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types index 86eb42efc0593..0ea9f7db87ce7 100644 --- a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types +++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3ES6.ts === - var t1 = 10; >t1 : number >10 : 10 diff --git a/tests/baselines/reference/emitPostComments.js b/tests/baselines/reference/emitPostComments.js index 8a5736af00d42..c37e097a7cf6a 100644 --- a/tests/baselines/reference/emitPostComments.js +++ b/tests/baselines/reference/emitPostComments.js @@ -1,5 +1,4 @@ //// [emitPostComments.ts] - var y = 10; /** * @name Foo diff --git a/tests/baselines/reference/emitPostComments.symbols b/tests/baselines/reference/emitPostComments.symbols index 296d8081058ea..8c8cd4a9f8ada 100644 --- a/tests/baselines/reference/emitPostComments.symbols +++ b/tests/baselines/reference/emitPostComments.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/emitPostComments.ts === - var y = 10; ->y : Symbol(y, Decl(emitPostComments.ts, 1, 3)) +>y : Symbol(y, Decl(emitPostComments.ts, 0, 3)) /** * @name Foo diff --git a/tests/baselines/reference/emitPostComments.types b/tests/baselines/reference/emitPostComments.types index dd73d8524236a..419bc6e240869 100644 --- a/tests/baselines/reference/emitPostComments.types +++ b/tests/baselines/reference/emitPostComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/emitPostComments.ts === - var y = 10; >y : number >10 : 10 diff --git a/tests/baselines/reference/emitPreComments.js b/tests/baselines/reference/emitPreComments.js index 4ca3297fce7fa..2694fa5b47de5 100644 --- a/tests/baselines/reference/emitPreComments.js +++ b/tests/baselines/reference/emitPreComments.js @@ -1,5 +1,4 @@ //// [emitPreComments.ts] - // This is pre comment var y = 10; /** diff --git a/tests/baselines/reference/emitPreComments.symbols b/tests/baselines/reference/emitPreComments.symbols index c90547bb6b851..321295930c6f2 100644 --- a/tests/baselines/reference/emitPreComments.symbols +++ b/tests/baselines/reference/emitPreComments.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/emitPreComments.ts === - // This is pre comment var y = 10; ->y : Symbol(y, Decl(emitPreComments.ts, 2, 3)) +>y : Symbol(y, Decl(emitPreComments.ts, 1, 3)) /** * @name Foo diff --git a/tests/baselines/reference/emitPreComments.types b/tests/baselines/reference/emitPreComments.types index 5ba8e45f721f2..557def62fb550 100644 --- a/tests/baselines/reference/emitPreComments.types +++ b/tests/baselines/reference/emitPreComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/emitPreComments.ts === - // This is pre comment var y = 10; >y : number diff --git a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.js b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.js index ff35851856853..387f700e8e98c 100644 --- a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.js +++ b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.ts] //// //// [file0.ts] - var x = 10 //// [file1.ts] diff --git a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.symbols b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.symbols index 1c0e48e00f2c7..efec6d76606c9 100644 --- a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.symbols +++ b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.symbols @@ -10,7 +10,6 @@ interface F { } === tests/cases/compiler/file0.ts === - var x = 10 ->x : Symbol(x, Decl(file0.ts, 1, 3)) +>x : Symbol(x, Decl(file0.ts, 0, 3)) diff --git a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.types b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.types index b5c1cd2b346fb..2d0223f90abc3 100644 --- a/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.types +++ b/tests/baselines/reference/emitTopOfFileTripleSlashCommentOnNotEmittedNodeIfRemoveCommentsIsFalse.types @@ -10,7 +10,6 @@ interface F { } === tests/cases/compiler/file0.ts === - var x = 10 >x : number >10 : 10 diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.js b/tests/baselines/reference/emptyArrayBindingPatternParameter01.js index 1eb76741e843f..d310fa64572e7 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter01.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.js @@ -1,5 +1,4 @@ //// [emptyArrayBindingPatternParameter01.ts] - function f([]) { var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols index e1630be639b7e..cbd0f64e76645 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts === - function f([]) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter01.ts, 0, 0)) var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter01.ts, 2, 7)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter01.ts, 2, 10)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter01.ts, 2, 13)) +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter01.ts, 1, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter01.ts, 1, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter01.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.types b/tests/baselines/reference/emptyArrayBindingPatternParameter01.types index 4ca0b892ecf39..7665ee42d861c 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter01.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts === - function f([]) { >f : ([]: any[]) => void diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.js b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js index d6dda16e12fe7..6f8b36b665e6c 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js @@ -1,5 +1,4 @@ //// [emptyArrayBindingPatternParameter02.ts] - function f(a, []) { var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols index 3289c06f962a4..3973cf9a7e015 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts === - function f(a, []) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter02.ts, 0, 0)) ->a : Symbol(a, Decl(emptyArrayBindingPatternParameter02.ts, 1, 11)) +>a : Symbol(a, Decl(emptyArrayBindingPatternParameter02.ts, 0, 11)) var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 2, 7)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 2, 10)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 2, 13)) +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 1, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 1, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.types b/tests/baselines/reference/emptyArrayBindingPatternParameter02.types index 34d9e7dde6b6f..f944bb3349bc4 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts === - function f(a, []) { >f : (a: any, []: any[]) => void >a : any diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.js b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js index 4867b39ac2fa8..3e632bf041663 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js @@ -1,5 +1,4 @@ //// [emptyArrayBindingPatternParameter03.ts] - function f(a, []) { var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols index 86a95687310e9..d9b6784661ea2 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts === - function f(a, []) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter03.ts, 0, 0)) ->a : Symbol(a, Decl(emptyArrayBindingPatternParameter03.ts, 1, 11)) +>a : Symbol(a, Decl(emptyArrayBindingPatternParameter03.ts, 0, 11)) var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter03.ts, 2, 7)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter03.ts, 2, 10)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter03.ts, 2, 13)) +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter03.ts, 1, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter03.ts, 1, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter03.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.types b/tests/baselines/reference/emptyArrayBindingPatternParameter03.types index 1c5579ebe366e..922870dce9f06 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts === - function f(a, []) { >f : (a: any, []: any[]) => void >a : any diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.js b/tests/baselines/reference/emptyArrayBindingPatternParameter04.js index 692669169357e..1405cf6ecf527 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter04.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.js @@ -1,5 +1,4 @@ //// [emptyArrayBindingPatternParameter04.ts] - function f([] = [1,2,3,4]) { var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols index 9f4c9bae0c6df..9b559dfe81c14 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts === - function f([] = [1,2,3,4]) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter04.ts, 0, 0)) var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter04.ts, 2, 7)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter04.ts, 2, 10)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter04.ts, 2, 13)) +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter04.ts, 1, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter04.ts, 1, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter04.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.types b/tests/baselines/reference/emptyArrayBindingPatternParameter04.types index f6035a6ba94da..16e65f159de76 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter04.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts === - function f([] = [1,2,3,4]) { >f : ([]?: number[]) => void >[1,2,3,4] : number[] diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.js b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.js index fe0a642c51e98..bd7ca29344631 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.js +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns01_ES5.ts] - var a: any; ({} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.symbols b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.symbols index 97752a1358d74..e8c3f93c01389 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 0, 3)) ({} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 0, 3)) ([] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.types b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.types index cbc0a25b074a1..b298c7f66eebd 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5.types +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js index 7123841025ffd..d3c41ea46a294 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns01_ES5iterable.ts] - var a: any; ({} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols index 8811c61dd9e0d..9d5fed4910570 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5iterable.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 0, 3)) ({} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 0, 3)) ([] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types index 4a5e17d7cdefa..4f60d19cfd1ee 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5iterable.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.js b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.js index 4cf33452d98a9..ab90b7cd89b41 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.js +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns01_ES6.ts] - var a: any; ({} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.symbols b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.symbols index 345bdd52265d1..d12e52ba1e812 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES6.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 0, 3)) ({} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 0, 3)) ([] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.types b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.types index c22c0e72854a1..770547f9e7bc2 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns01_ES6.types +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES6.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.js b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.js index f5434d4a1c344..2c4743b90f358 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.js +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns02_ES5.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.symbols b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.symbols index a575ea35f243c..a77099dbfa04c 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 20)) ({} = { x, y, z } = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5.ts, 4, 7)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5.ts, 4, 10)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5.ts, 4, 13)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5.ts, 3, 7)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5.ts, 3, 10)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5.ts, 3, 13)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 0, 3)) ([] = [ a1, a2, a3] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.types b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.types index 76897f8516ecc..383afeb7c9d16 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5.types +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js index 45cd426549e58..bcd57cff25c97 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns02_ES5iterable.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols index fc90df74d1d50..b8222c4da9c4e 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5iterable.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 20)) ({} = { x, y, z } = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 4, 7)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 4, 10)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 4, 13)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 3, 7)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 3, 10)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 3, 13)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 0, 3)) ([] = [ a1, a2, a3] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types index 5f19cd98ec48a..e75fca12e0f6b 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5iterable.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.js b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.js index 493246c94731e..df05fb669ee52 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.js +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns02_ES6.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.symbols b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.symbols index e55339cb658af..34659f0e34849 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES6.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 20)) ({} = { x, y, z } = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns02_ES6.ts, 4, 7)) ->y : Symbol(y, Decl(emptyAssignmentPatterns02_ES6.ts, 4, 10)) ->z : Symbol(z, Decl(emptyAssignmentPatterns02_ES6.ts, 4, 13)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES6.ts, 3, 7)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES6.ts, 3, 10)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES6.ts, 3, 13)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 0, 3)) ([] = [ a1, a2, a3] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES6.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES6.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.types b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.types index 48c9146e15466..b62aba04e7cd6 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns02_ES6.types +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES6.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.js b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.js index adaad2e3b63bd..26d59e28b51fe 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.js +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns03_ES5.ts] - var a: any; ({} = {} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.symbols b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.symbols index c57365bc7d026..d7e5cd265fc18 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 0, 3)) ({} = {} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 0, 3)) ([] = [] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.types b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.types index 4f32b0555ef1c..76c63ca761cae 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5.types +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js index 79806e5994d1e..925e15918dbb1 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns03_ES5iterable.ts] - var a: any; ({} = {} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols index e1ac0ea4c5c53..4b066259d18c7 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5iterable.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 0, 3)) ({} = {} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 0, 3)) ([] = [] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types index 273d360d92f25..5e7b867f44b2e 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5iterable.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.js b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.js index 8050cc1e47abb..2a3e1462bca1a 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.js +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns03_ES6.ts] - var a: any; ({} = {} = a); diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.symbols b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.symbols index 3e32848207a45..9df1375cb55c2 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES6.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 0, 3)) ({} = {} = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 0, 3)) ([] = [] = a); ->a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.types b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.types index 1f1d005aac5fc..9e826e4b92b93 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns03_ES6.types +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES6.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.js b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.js index 91559d18252eb..d2c3c1a1fa991 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.js +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns04_ES5.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.symbols b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.symbols index 20ea8c037c378..b362119333eea 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 20)) ({ x, y, z } = {} = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5.ts, 4, 2)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5.ts, 4, 5)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5.ts, 4, 8)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5.ts, 3, 2)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5.ts, 3, 5)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5.ts, 3, 8)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 0, 3)) ([ a1, a2, a3] = [] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.types b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.types index 5ae2f0674fab1..0c8672917774b 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5.types +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js index 5cb4a63b03d09..36c124be51193 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns04_ES5iterable.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols index d433a0f125cbc..f2b185f5c15cc 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5iterable.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 20)) ({ x, y, z } = {} = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 4, 2)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 4, 5)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 4, 8)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 3, 2)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 3, 5)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 3, 8)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 0, 3)) ([ a1, a2, a3] = [] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types index c926ec31bfa28..cfd3991852ce5 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5iterable.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.js b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.js index fb52975d6d18a..a00bc8d0c66a1 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.js +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.js @@ -1,5 +1,4 @@ //// [emptyAssignmentPatterns04_ES6.ts] - var a: any; let x, y, z, a1, a2, a3; diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.symbols b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.symbols index ee793cd318710..cfbe128fcdb9c 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.symbols +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES6.ts === - var a: any; ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 0, 3)) let x, y, z, a1, a2, a3; ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 3)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 6)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 9)) ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 20)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 20)) ({ x, y, z } = {} = a); ->x : Symbol(x, Decl(emptyAssignmentPatterns04_ES6.ts, 4, 2)) ->y : Symbol(y, Decl(emptyAssignmentPatterns04_ES6.ts, 4, 5)) ->z : Symbol(z, Decl(emptyAssignmentPatterns04_ES6.ts, 4, 8)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES6.ts, 3, 2)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES6.ts, 3, 5)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES6.ts, 3, 8)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 0, 3)) ([ a1, a2, a3] = [] = a); ->a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 12)) ->a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 16)) ->a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES6.ts, 2, 20)) ->a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 3)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES6.ts, 1, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.types b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.types index 6bd855937483c..d92c91b057621 100644 --- a/tests/baselines/reference/emptyAssignmentPatterns04_ES6.types +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES6.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.js b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js index 6a8ec808cd066..92b516377fdf6 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js @@ -1,5 +1,4 @@ //// [emptyObjectBindingPatternParameter01.ts] - function f({}) { var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols index 3ef5898c29a4e..464b0a170a3e1 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts === - function f({}) { >f : Symbol(f, Decl(emptyObjectBindingPatternParameter01.ts, 0, 0)) var x, y, z; ->x : Symbol(x, Decl(emptyObjectBindingPatternParameter01.ts, 2, 7)) ->y : Symbol(y, Decl(emptyObjectBindingPatternParameter01.ts, 2, 10)) ->z : Symbol(z, Decl(emptyObjectBindingPatternParameter01.ts, 2, 13)) +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter01.ts, 1, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter01.ts, 1, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter01.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.types b/tests/baselines/reference/emptyObjectBindingPatternParameter01.types index 05ddc54719cdc..d2326c5e18ca7 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.types +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts === - function f({}) { >f : ({}: {}) => void diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.js b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js index be2bdcab29816..35488656e2276 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js @@ -1,5 +1,4 @@ //// [emptyObjectBindingPatternParameter02.ts] - function f(a, {}) { var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols index d5bb4f292aa41..cf3f36d720801 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts === - function f(a, {}) { >f : Symbol(f, Decl(emptyObjectBindingPatternParameter02.ts, 0, 0)) ->a : Symbol(a, Decl(emptyObjectBindingPatternParameter02.ts, 1, 11)) +>a : Symbol(a, Decl(emptyObjectBindingPatternParameter02.ts, 0, 11)) var x, y, z; ->x : Symbol(x, Decl(emptyObjectBindingPatternParameter02.ts, 2, 7)) ->y : Symbol(y, Decl(emptyObjectBindingPatternParameter02.ts, 2, 10)) ->z : Symbol(z, Decl(emptyObjectBindingPatternParameter02.ts, 2, 13)) +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter02.ts, 1, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter02.ts, 1, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter02.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.types b/tests/baselines/reference/emptyObjectBindingPatternParameter02.types index e2b485538e6d0..56b50e11602dc 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.types +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts === - function f(a, {}) { >f : (a: any, {}: {}) => void >a : any diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.js b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js index 320bfe2d0df30..e4ce7e6fc393c 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js @@ -1,5 +1,4 @@ //// [emptyObjectBindingPatternParameter03.ts] - function f({}, a) { var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols index 82a1bcee75b98..87c584a463489 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts === - function f({}, a) { >f : Symbol(f, Decl(emptyObjectBindingPatternParameter03.ts, 0, 0)) ->a : Symbol(a, Decl(emptyObjectBindingPatternParameter03.ts, 1, 14)) +>a : Symbol(a, Decl(emptyObjectBindingPatternParameter03.ts, 0, 14)) var x, y, z; ->x : Symbol(x, Decl(emptyObjectBindingPatternParameter03.ts, 2, 7)) ->y : Symbol(y, Decl(emptyObjectBindingPatternParameter03.ts, 2, 10)) ->z : Symbol(z, Decl(emptyObjectBindingPatternParameter03.ts, 2, 13)) +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter03.ts, 1, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter03.ts, 1, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter03.ts, 1, 13)) } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.types b/tests/baselines/reference/emptyObjectBindingPatternParameter03.types index 0f89702402a55..c5938402d0a23 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.types +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts === - function f({}, a) { >f : ({}: {}, a: any) => void >a : any diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.errors.txt b/tests/baselines/reference/emptyObjectBindingPatternParameter04.errors.txt index 03b58378a0f3e..52b69127f79c2 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter04.errors.txt +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(2,18): error TS2353: Object literal may only specify known properties, and 'a' does not exist in type '{}'. -tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(2,24): error TS2353: Object literal may only specify known properties, and 'b' does not exist in type '{}'. -tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(2,32): error TS2353: Object literal may only specify known properties, and 'c' does not exist in type '{}'. +tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(1,18): error TS2353: Object literal may only specify known properties, and 'a' does not exist in type '{}'. +tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(1,24): error TS2353: Object literal may only specify known properties, and 'b' does not exist in type '{}'. +tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts(1,32): error TS2353: Object literal may only specify known properties, and 'c' does not exist in type '{}'. ==== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts (3 errors) ==== - function f({} = {a: 1, b: "2", c: true}) { ~ !!! error TS2353: Object literal may only specify known properties, and 'a' does not exist in type '{}'. diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.js b/tests/baselines/reference/emptyObjectBindingPatternParameter04.js index 8d91e8f34c371..c18ae67ac4b1e 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter04.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.js @@ -1,5 +1,4 @@ //// [emptyObjectBindingPatternParameter04.ts] - function f({} = {a: 1, b: "2", c: true}) { var x, y, z; } diff --git a/tests/baselines/reference/emptyTuplesTypeAssertion01.errors.txt b/tests/baselines/reference/emptyTuplesTypeAssertion01.errors.txt index 4d70873bd74b6..bfe850a5749bf 100644 --- a/tests/baselines/reference/emptyTuplesTypeAssertion01.errors.txt +++ b/tests/baselines/reference/emptyTuplesTypeAssertion01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion01.ts(2,10): error TS1122: A tuple type element list cannot be empty. +tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion01.ts(1,10): error TS1122: A tuple type element list cannot be empty. ==== tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion01.ts (1 errors) ==== - let x = <[]>[]; ~~ !!! error TS1122: A tuple type element list cannot be empty. diff --git a/tests/baselines/reference/emptyTuplesTypeAssertion01.js b/tests/baselines/reference/emptyTuplesTypeAssertion01.js index 6ab1ec82bd5bd..8ee48da9a56cf 100644 --- a/tests/baselines/reference/emptyTuplesTypeAssertion01.js +++ b/tests/baselines/reference/emptyTuplesTypeAssertion01.js @@ -1,5 +1,4 @@ //// [emptyTuplesTypeAssertion01.ts] - let x = <[]>[]; let y = x[0]; diff --git a/tests/baselines/reference/emptyTuplesTypeAssertion02.errors.txt b/tests/baselines/reference/emptyTuplesTypeAssertion02.errors.txt index 0cbc0d7371c2c..1bbf96e6aec70 100644 --- a/tests/baselines/reference/emptyTuplesTypeAssertion02.errors.txt +++ b/tests/baselines/reference/emptyTuplesTypeAssertion02.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion02.ts(2,15): error TS1122: A tuple type element list cannot be empty. +tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion02.ts(1,15): error TS1122: A tuple type element list cannot be empty. ==== tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion02.ts (1 errors) ==== - let x = [] as []; ~~ !!! error TS1122: A tuple type element list cannot be empty. diff --git a/tests/baselines/reference/emptyTuplesTypeAssertion02.js b/tests/baselines/reference/emptyTuplesTypeAssertion02.js index ad112732cd261..41607e53b4098 100644 --- a/tests/baselines/reference/emptyTuplesTypeAssertion02.js +++ b/tests/baselines/reference/emptyTuplesTypeAssertion02.js @@ -1,5 +1,4 @@ //// [emptyTuplesTypeAssertion02.ts] - let x = [] as []; let y = x[0]; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js index 655a9f073a249..c9b30a9390663 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns01_ES5.ts] - (function () { var a: any; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.symbols b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.symbols index ddba9738e087b..84351c06f0a02 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.symbols +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.symbols @@ -1,92 +1,91 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5.ts === - (function () { var a: any; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) var {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) let {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) const {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) var [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) let [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) const [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) var {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) let {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) const {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) var { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) let { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) const { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { ->f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 21, 5)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 20, 5)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) return ({} = a, [] = a, { p: {} = a } = a) => a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 1, 7)) } })(); (function () { const ns: number[][] = []; ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) for (var {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (let {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (const {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (var [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (let [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } for (const [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5.ts, 28, 9)) } })(); diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types index 9b6112365fdb8..c61c80c5b3df5 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5.ts === - (function () { >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }})() : void >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }}) : () => void diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js index c4eeb9994e698..d4632999e0c1c 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns01_ES5iterable.ts] - (function () { var a: any; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols index d77525cf7678a..38b911d7071cc 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols @@ -1,92 +1,91 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5iterable.ts === - (function () { var a: any; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) var {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) let {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) const {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) var [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) let [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) const [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) var {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) let {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) const {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) var { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) let { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) const { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { ->f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 21, 5)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 20, 5)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) return ({} = a, [] = a, { p: {} = a } = a) => a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 1, 7)) } })(); (function () { const ns: number[][] = []; ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) for (var {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (let {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (const {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (var [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (let [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } for (const [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 28, 9)) } })(); diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types index 591b149ac075b..9c623fd88798a 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5iterable.ts === - (function () { >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }})() : void >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }}) : () => void diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.js index 98661c440c647..86bb3ca0a8924 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns01_ES6.ts] - (function () { var a: any; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.symbols b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.symbols index 6a826d4b6c956..604e948aba972 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.symbols +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.symbols @@ -1,92 +1,91 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES6.ts === - (function () { var a: any; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) var {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) let {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) const {} = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) var [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) let [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) const [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) var {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) let {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) const {} = a, [] = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) var { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) let { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) const { p1: {}, p2: [] } = a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { ->f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 21, 5)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 20, 5)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) return ({} = a, [] = a, { p: {} = a } = a) => a; ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) ->a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 1, 7)) } })(); (function () { const ns: number[][] = []; ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) for (var {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (let {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (const {} of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (var [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (let [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } for (const [] of ns) { ->ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 29, 9)) +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES6.ts, 28, 9)) } })(); diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types index ac79fe0b1b738..48d5f40b97117 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES6.ts === - (function () { >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }})() : void >(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }}) : () => void diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.errors.txt b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.errors.txt index b589b075ecb8d..5825a43c28db4 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.errors.txt +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.errors.txt @@ -1,13 +1,12 @@ +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(2,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(3,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(4,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(5,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(4,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(6,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(7,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(8,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(9,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts(8,11): error TS1182: A destructuring declaration must have an initializer. ==== tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5.ts (6 errors) ==== - (function () { var {}; ~~ diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.js index 7710b5e26c1c9..1fbb527a827ce 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns02_ES5.ts] - (function () { var {}; let {}; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt index 453f44be10c9e..29c51ecd3f23c 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt @@ -1,13 +1,12 @@ +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(2,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(3,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(4,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(5,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(4,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(6,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(7,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(8,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(9,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(8,11): error TS1182: A destructuring declaration must have an initializer. ==== tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts (6 errors) ==== - (function () { var {}; ~~ diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js index b5457d0a2ece0..24ba247daf842 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns02_ES5iterable.ts] - (function () { var {}; let {}; diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.errors.txt b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.errors.txt index 81349584f4791..ffd6ab09cf792 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.errors.txt +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.errors.txt @@ -1,13 +1,12 @@ +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(2,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(3,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(4,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(5,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(4,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(6,9): error TS1182: A destructuring declaration must have an initializer. tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(7,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(8,9): error TS1182: A destructuring declaration must have an initializer. -tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(9,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts(8,11): error TS1182: A destructuring declaration must have an initializer. ==== tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES6.ts (6 errors) ==== - (function () { var {}; ~~ diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.js index 9b78828cc49dc..41f362f79fc34 100644 --- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.js +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.js @@ -1,5 +1,4 @@ //// [emptyVariableDeclarationBindingPatterns02_ES6.ts] - (function () { var {}; let {}; diff --git a/tests/baselines/reference/enumDecl1.js b/tests/baselines/reference/enumDecl1.js index fb1c00a19a69d..383f463d51c93 100644 --- a/tests/baselines/reference/enumDecl1.js +++ b/tests/baselines/reference/enumDecl1.js @@ -1,5 +1,4 @@ //// [enumDecl1.ts] - declare module mAmbient { enum e { x, diff --git a/tests/baselines/reference/enumDecl1.symbols b/tests/baselines/reference/enumDecl1.symbols index fc8d900ff042d..71f6e48e553ba 100644 --- a/tests/baselines/reference/enumDecl1.symbols +++ b/tests/baselines/reference/enumDecl1.symbols @@ -1,19 +1,18 @@ === tests/cases/compiler/enumDecl1.ts === - declare module mAmbient { >mAmbient : Symbol(mAmbient, Decl(enumDecl1.ts, 0, 0)) enum e { ->e : Symbol(e, Decl(enumDecl1.ts, 1, 25)) +>e : Symbol(e, Decl(enumDecl1.ts, 0, 25)) x, ->x : Symbol(e.x, Decl(enumDecl1.ts, 2, 12)) +>x : Symbol(e.x, Decl(enumDecl1.ts, 1, 12)) y, ->y : Symbol(e.y, Decl(enumDecl1.ts, 3, 10)) +>y : Symbol(e.y, Decl(enumDecl1.ts, 2, 10)) z ->z : Symbol(e.z, Decl(enumDecl1.ts, 4, 10)) +>z : Symbol(e.z, Decl(enumDecl1.ts, 3, 10)) } } diff --git a/tests/baselines/reference/enumDecl1.types b/tests/baselines/reference/enumDecl1.types index 22d2b6b4d69a1..3f73e33f93278 100644 --- a/tests/baselines/reference/enumDecl1.types +++ b/tests/baselines/reference/enumDecl1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/enumDecl1.ts === - declare module mAmbient { >mAmbient : typeof mAmbient diff --git a/tests/baselines/reference/enumLiteralTypes2.js b/tests/baselines/reference/enumLiteralTypes2.js index 0b2b6d35c5340..a7d6f1128002b 100644 --- a/tests/baselines/reference/enumLiteralTypes2.js +++ b/tests/baselines/reference/enumLiteralTypes2.js @@ -1,5 +1,4 @@ //// [enumLiteralTypes2.ts] - const enum Choice { Unknown, Yes, No }; type YesNo = Choice.Yes | Choice.No; diff --git a/tests/baselines/reference/enumLiteralTypes2.symbols b/tests/baselines/reference/enumLiteralTypes2.symbols index 3bd937c3706fa..951404c5f9ec8 100644 --- a/tests/baselines/reference/enumLiteralTypes2.symbols +++ b/tests/baselines/reference/enumLiteralTypes2.symbols @@ -1,412 +1,411 @@ === tests/cases/conformance/types/literal/enumLiteralTypes2.ts === - const enum Choice { Unknown, Yes, No }; >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes2.ts, 1, 19)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes2.ts, 0, 19)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) type YesNo = Choice.Yes | Choice.No; ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) type NoYes = Choice.No | Choice.Yes; ->NoYes : Symbol(NoYes, Decl(enumLiteralTypes2.ts, 3, 36)) +>NoYes : Symbol(NoYes, Decl(enumLiteralTypes2.ts, 2, 36)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No; ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes2.ts, 1, 19)) +>Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes2.ts, 0, 19)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) function f1() { ->f1 : Symbol(f1, Decl(enumLiteralTypes2.ts, 5, 60)) +>f1 : Symbol(f1, Decl(enumLiteralTypes2.ts, 4, 60)) var a: YesNo; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7), Decl(enumLiteralTypes2.ts, 11, 7)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 7, 7), Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) var a: NoYes; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7), Decl(enumLiteralTypes2.ts, 11, 7)) ->NoYes : Symbol(NoYes, Decl(enumLiteralTypes2.ts, 3, 36)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 7, 7), Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7)) +>NoYes : Symbol(NoYes, Decl(enumLiteralTypes2.ts, 2, 36)) var a: Choice.Yes | Choice.No; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7), Decl(enumLiteralTypes2.ts, 11, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 7, 7), Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) var a: Choice.No | Choice.Yes; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7), Decl(enumLiteralTypes2.ts, 11, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 7, 7), Decl(enumLiteralTypes2.ts, 8, 7), Decl(enumLiteralTypes2.ts, 9, 7), Decl(enumLiteralTypes2.ts, 10, 7)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) } function f2(a: YesNo, b: UnknownYesNo, c: Choice) { ->f2 : Symbol(f2, Decl(enumLiteralTypes2.ts, 12, 1)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 14, 12)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 14, 21)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 14, 38)) +>f2 : Symbol(f2, Decl(enumLiteralTypes2.ts, 11, 1)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 13, 12)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 13, 21)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 13, 38)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) b = a; ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 14, 21)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 14, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 13, 21)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 13, 12)) c = a; ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 14, 38)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 14, 12)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 13, 38)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 13, 12)) c = b; ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 14, 38)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 14, 21)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 13, 38)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 13, 21)) } function f3(a: Choice.Yes, b: UnknownYesNo) { ->f3 : Symbol(f3, Decl(enumLiteralTypes2.ts, 18, 1)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) +>f3 : Symbol(f3, Decl(enumLiteralTypes2.ts, 17, 1)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) var x = a + b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a - b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a * b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a / b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a % b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a | b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a & b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = a ^ b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = -b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var x = ~b; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7), Decl(enumLiteralTypes2.ts, 30, 7)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 20, 7), Decl(enumLiteralTypes2.ts, 21, 7), Decl(enumLiteralTypes2.ts, 22, 7), Decl(enumLiteralTypes2.ts, 23, 7), Decl(enumLiteralTypes2.ts, 24, 7), Decl(enumLiteralTypes2.ts, 25, 7), Decl(enumLiteralTypes2.ts, 26, 7), Decl(enumLiteralTypes2.ts, 27, 7), Decl(enumLiteralTypes2.ts, 28, 7), Decl(enumLiteralTypes2.ts, 29, 7)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a == b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a != b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a === b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a !== b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a > b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a < b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a >= b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = a <= b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 20, 12)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 19, 12)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) var y = !b; ->y : Symbol(y, Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7), Decl(enumLiteralTypes2.ts, 39, 7)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 20, 26)) +>y : Symbol(y, Decl(enumLiteralTypes2.ts, 30, 7), Decl(enumLiteralTypes2.ts, 31, 7), Decl(enumLiteralTypes2.ts, 32, 7), Decl(enumLiteralTypes2.ts, 33, 7), Decl(enumLiteralTypes2.ts, 34, 7), Decl(enumLiteralTypes2.ts, 35, 7), Decl(enumLiteralTypes2.ts, 36, 7), Decl(enumLiteralTypes2.ts, 37, 7), Decl(enumLiteralTypes2.ts, 38, 7)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 19, 26)) } function f4(a: Choice.Yes, b: UnknownYesNo) { ->f4 : Symbol(f4, Decl(enumLiteralTypes2.ts, 40, 1)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 42, 12)) +>f4 : Symbol(f4, Decl(enumLiteralTypes2.ts, 39, 1)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 41, 12)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 42, 26)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 41, 26)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) a++; ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 42, 12)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 41, 12)) b++; ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 42, 26)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 41, 26)) } declare function g(x: Choice.Yes): string; ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 47, 19)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 46, 19)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) declare function g(x: Choice.No): boolean; ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 48, 19)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 47, 19)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) declare function g(x: Choice): number; ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 49, 19)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 48, 19)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) function f5(a: YesNo, b: UnknownYesNo, c: Choice) { ->f5 : Symbol(f5, Decl(enumLiteralTypes2.ts, 49, 38)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 51, 12)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 51, 21)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 51, 38)) +>f5 : Symbol(f5, Decl(enumLiteralTypes2.ts, 48, 38)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 50, 12)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 50, 21)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 50, 38)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) var z1 = g(Choice.Yes); ->z1 : Symbol(z1, Decl(enumLiteralTypes2.ts, 52, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>z1 : Symbol(z1, Decl(enumLiteralTypes2.ts, 51, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) var z2 = g(Choice.No); ->z2 : Symbol(z2, Decl(enumLiteralTypes2.ts, 53, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>z2 : Symbol(z2, Decl(enumLiteralTypes2.ts, 52, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) var z3 = g(a); ->z3 : Symbol(z3, Decl(enumLiteralTypes2.ts, 54, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 51, 12)) +>z3 : Symbol(z3, Decl(enumLiteralTypes2.ts, 53, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 50, 12)) var z4 = g(b); ->z4 : Symbol(z4, Decl(enumLiteralTypes2.ts, 55, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 51, 21)) +>z4 : Symbol(z4, Decl(enumLiteralTypes2.ts, 54, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 50, 21)) var z5 = g(c); ->z5 : Symbol(z5, Decl(enumLiteralTypes2.ts, 56, 7)) ->g : Symbol(g, Decl(enumLiteralTypes2.ts, 45, 1), Decl(enumLiteralTypes2.ts, 47, 42), Decl(enumLiteralTypes2.ts, 48, 42)) ->c : Symbol(c, Decl(enumLiteralTypes2.ts, 51, 38)) +>z5 : Symbol(z5, Decl(enumLiteralTypes2.ts, 55, 7)) +>g : Symbol(g, Decl(enumLiteralTypes2.ts, 44, 1), Decl(enumLiteralTypes2.ts, 46, 42), Decl(enumLiteralTypes2.ts, 47, 42)) +>c : Symbol(c, Decl(enumLiteralTypes2.ts, 50, 38)) } function assertNever(x: never): never { ->assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 57, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 59, 21)) +>assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 56, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 58, 21)) throw new Error("Unexpected value"); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function f10(x: YesNo) { ->f10 : Symbol(f10, Decl(enumLiteralTypes2.ts, 61, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 63, 13)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) +>f10 : Symbol(f10, Decl(enumLiteralTypes2.ts, 60, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 62, 13)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) switch (x) { ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 63, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 62, 13)) case Choice.Yes: return "true"; ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) case Choice.No: return "false"; ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) } } function f11(x: YesNo) { ->f11 : Symbol(f11, Decl(enumLiteralTypes2.ts, 68, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 70, 13)) ->YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 1, 39)) +>f11 : Symbol(f11, Decl(enumLiteralTypes2.ts, 67, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 69, 13)) +>YesNo : Symbol(YesNo, Decl(enumLiteralTypes2.ts, 0, 39)) switch (x) { ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 70, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 69, 13)) case Choice.Yes: return "true"; ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) case Choice.No: return "false"; ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 57, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 70, 13)) +>assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 56, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 69, 13)) } function f12(x: UnknownYesNo) { ->f12 : Symbol(f12, Decl(enumLiteralTypes2.ts, 76, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 78, 13)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>f12 : Symbol(f12, Decl(enumLiteralTypes2.ts, 75, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 77, 13)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) if (x) { ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 78, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 77, 13)) x; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 78, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 77, 13)) } else { x; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 78, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 77, 13)) } } function f13(x: UnknownYesNo) { ->f13 : Symbol(f13, Decl(enumLiteralTypes2.ts, 85, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 87, 13)) ->UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 4, 36)) +>f13 : Symbol(f13, Decl(enumLiteralTypes2.ts, 84, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 86, 13)) +>UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes2.ts, 3, 36)) if (x === Choice.Yes) { ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 87, 13)) ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 86, 13)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) x; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 86, 13)) } else { x; ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 86, 13)) } } type Item = ->Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 94, 1)) +>Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 93, 1)) { kind: Choice.Yes, a: string } | ->kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5)) +>kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) { kind: Choice.No, b: string }; ->kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 98, 5)) +>kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) function f20(x: Item) { ->f20 : Symbol(f20, Decl(enumLiteralTypes2.ts, 98, 35)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 100, 13)) ->Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 94, 1)) +>f20 : Symbol(f20, Decl(enumLiteralTypes2.ts, 97, 35)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 99, 13)) +>Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 93, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5), Decl(enumLiteralTypes2.ts, 98, 5)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 100, 13)) ->kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5), Decl(enumLiteralTypes2.ts, 98, 5)) +>x.kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5), Decl(enumLiteralTypes2.ts, 97, 5)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 99, 13)) +>kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5), Decl(enumLiteralTypes2.ts, 97, 5)) case Choice.Yes: return x.a; ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->x.a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 100, 13)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>x.a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 99, 13)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) case Choice.No: return x.b; ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) ->x.b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 100, 13)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) +>x.b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 99, 13)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) } } function f21(x: Item) { ->f21 : Symbol(f21, Decl(enumLiteralTypes2.ts, 105, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) ->Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 94, 1)) +>f21 : Symbol(f21, Decl(enumLiteralTypes2.ts, 104, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) +>Item : Symbol(Item, Decl(enumLiteralTypes2.ts, 93, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5), Decl(enumLiteralTypes2.ts, 98, 5)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) ->kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 97, 5), Decl(enumLiteralTypes2.ts, 98, 5)) +>x.kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5), Decl(enumLiteralTypes2.ts, 97, 5)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) +>kind : Symbol(kind, Decl(enumLiteralTypes2.ts, 96, 5), Decl(enumLiteralTypes2.ts, 97, 5)) case Choice.Yes: return x.a; ->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) +>Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 1, 28)) ->x.a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) ->a : Symbol(a, Decl(enumLiteralTypes2.ts, 97, 23)) +>Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes2.ts, 0, 28)) +>x.a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) +>a : Symbol(a, Decl(enumLiteralTypes2.ts, 96, 23)) case Choice.No: return x.b; ->Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) +>Choice.No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) >Choice : Symbol(Choice, Decl(enumLiteralTypes2.ts, 0, 0)) ->No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 1, 33)) ->x.b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) ->b : Symbol(b, Decl(enumLiteralTypes2.ts, 98, 22)) +>No : Symbol(Choice.No, Decl(enumLiteralTypes2.ts, 0, 33)) +>x.b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) +>b : Symbol(b, Decl(enumLiteralTypes2.ts, 97, 22)) } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 57, 1)) ->x : Symbol(x, Decl(enumLiteralTypes2.ts, 107, 13)) +>assertNever : Symbol(assertNever, Decl(enumLiteralTypes2.ts, 56, 1)) +>x : Symbol(x, Decl(enumLiteralTypes2.ts, 106, 13)) } diff --git a/tests/baselines/reference/enumLiteralTypes2.types b/tests/baselines/reference/enumLiteralTypes2.types index 6b881bee8c30c..4a8c2ae01dc4b 100644 --- a/tests/baselines/reference/enumLiteralTypes2.types +++ b/tests/baselines/reference/enumLiteralTypes2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/enumLiteralTypes2.ts === - const enum Choice { Unknown, Yes, No }; >Choice : Choice >Unknown : Choice.Unknown diff --git a/tests/baselines/reference/equalityStrictNulls.errors.txt b/tests/baselines/reference/equalityStrictNulls.errors.txt index 16772d8eeab1f..88694f5dddd83 100644 --- a/tests/baselines/reference/equalityStrictNulls.errors.txt +++ b/tests/baselines/reference/equalityStrictNulls.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(60,13): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(62,13): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(64,14): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(66,14): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(59,13): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(61,13): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(63,14): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(65,14): error TS2532: Object is possibly 'undefined'. ==== tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts (4 errors) ==== - function f1(x: string) { if (x == undefined) { } diff --git a/tests/baselines/reference/equalityStrictNulls.js b/tests/baselines/reference/equalityStrictNulls.js index e34e9fe9989e3..650bd147a02e2 100644 --- a/tests/baselines/reference/equalityStrictNulls.js +++ b/tests/baselines/reference/equalityStrictNulls.js @@ -1,5 +1,4 @@ //// [equalityStrictNulls.ts] - function f1(x: string) { if (x == undefined) { } diff --git a/tests/baselines/reference/errorSupression1.errors.txt b/tests/baselines/reference/errorSupression1.errors.txt index 206a78ebf4552..9977fa894ca83 100644 --- a/tests/baselines/reference/errorSupression1.errors.txt +++ b/tests/baselines/reference/errorSupression1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/errorSupression1.ts(4,15): error TS2339: Property 'b' does not exist on type 'typeof Foo'. +tests/cases/compiler/errorSupression1.ts(3,15): error TS2339: Property 'b' does not exist on type 'typeof Foo'. ==== tests/cases/compiler/errorSupression1.ts (1 errors) ==== - class Foo { static bar() { return "x"; } } var baz = Foo.b; diff --git a/tests/baselines/reference/errorSupression1.js b/tests/baselines/reference/errorSupression1.js index 77545131ce344..e43e47adeda7a 100644 --- a/tests/baselines/reference/errorSupression1.js +++ b/tests/baselines/reference/errorSupression1.js @@ -1,5 +1,4 @@ //// [errorSupression1.ts] - class Foo { static bar() { return "x"; } } var baz = Foo.b; diff --git a/tests/baselines/reference/errorWithTruncatedType.errors.txt b/tests/baselines/reference/errorWithTruncatedType.errors.txt index f073f7c50a4b4..33714b8626280 100644 --- a/tests/baselines/reference/errorWithTruncatedType.errors.txt +++ b/tests/baselines/reference/errorWithTruncatedType.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/errorWithTruncatedType.ts(11,5): error TS2322: Type '{ propertyWithAnExceedinglyLongName1: string; propertyWithAnExceedinglyLongName2: string; propert...' is not assignable to type 'string'. +tests/cases/compiler/errorWithTruncatedType.ts(10,5): error TS2322: Type '{ propertyWithAnExceedinglyLongName1: string; propertyWithAnExceedinglyLongName2: string; propert...' is not assignable to type 'string'. ==== tests/cases/compiler/errorWithTruncatedType.ts (1 errors) ==== - var x: { propertyWithAnExceedinglyLongName1: string; propertyWithAnExceedinglyLongName2: string; diff --git a/tests/baselines/reference/errorWithTruncatedType.js b/tests/baselines/reference/errorWithTruncatedType.js index 5fd45579a299b..3c47f229f3621 100644 --- a/tests/baselines/reference/errorWithTruncatedType.js +++ b/tests/baselines/reference/errorWithTruncatedType.js @@ -1,5 +1,4 @@ //// [errorWithTruncatedType.ts] - var x: { propertyWithAnExceedinglyLongName1: string; propertyWithAnExceedinglyLongName2: string; diff --git a/tests/baselines/reference/errorsInGenericTypeReference.errors.txt b/tests/baselines/reference/errorsInGenericTypeReference.errors.txt index 729b4db544022..c459eee92901a 100644 --- a/tests/baselines/reference/errorsInGenericTypeReference.errors.txt +++ b/tests/baselines/reference/errorsInGenericTypeReference.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/errorsInGenericTypeReference.ts(12,17): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(18,31): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(23,29): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(24,36): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(25,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/errorsInGenericTypeReference.ts(25,27): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(26,24): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(31,36): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(35,36): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(39,17): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(43,33): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(45,41): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(48,27): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(52,25): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(57,35): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(61,39): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(66,22): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(66,38): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(67,27): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(11,17): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(17,31): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(22,29): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(23,36): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(24,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/errorsInGenericTypeReference.ts(24,27): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(25,24): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(30,36): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(34,36): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(38,17): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(42,33): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(44,41): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(47,27): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(51,25): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(56,35): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(60,39): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(65,22): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(65,38): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(66,27): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(67,24): error TS2304: Cannot find name 'V'. +tests/cases/compiler/errorsInGenericTypeReference.ts(67,40): error TS2304: Cannot find name 'V'. tests/cases/compiler/errorsInGenericTypeReference.ts(68,24): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(68,40): error TS2304: Cannot find name 'V'. -tests/cases/compiler/errorsInGenericTypeReference.ts(69,24): error TS2304: Cannot find name 'V'. ==== tests/cases/compiler/errorsInGenericTypeReference.ts (22 errors) ==== - interface IFoo { } class Foo { } diff --git a/tests/baselines/reference/errorsInGenericTypeReference.js b/tests/baselines/reference/errorsInGenericTypeReference.js index 2e54d0cf71cf7..ad999dcb913e4 100644 --- a/tests/baselines/reference/errorsInGenericTypeReference.js +++ b/tests/baselines/reference/errorsInGenericTypeReference.js @@ -1,5 +1,4 @@ //// [errorsInGenericTypeReference.ts] - interface IFoo { } class Foo { } diff --git a/tests/baselines/reference/errorsOnImportedSymbol.errors.txt b/tests/baselines/reference/errorsOnImportedSymbol.errors.txt index 127026a8e2cbe..52a0cf754c384 100644 --- a/tests/baselines/reference/errorsOnImportedSymbol.errors.txt +++ b/tests/baselines/reference/errorsOnImportedSymbol.errors.txt @@ -13,7 +13,6 @@ tests/cases/compiler/errorsOnImportedSymbol_1.ts(3,9): error TS2693: 'Sammy' onl ==== tests/cases/compiler/errorsOnImportedSymbol_0.ts (0 errors) ==== - interface Sammy { new (): any; (): number; diff --git a/tests/baselines/reference/errorsOnImportedSymbol.js b/tests/baselines/reference/errorsOnImportedSymbol.js index 15ae0c90bd1e6..2d784b04d6558 100644 --- a/tests/baselines/reference/errorsOnImportedSymbol.js +++ b/tests/baselines/reference/errorsOnImportedSymbol.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/errorsOnImportedSymbol.ts] //// //// [errorsOnImportedSymbol_0.ts] - interface Sammy { new (): any; (): number; diff --git a/tests/baselines/reference/es2015modulekind.js b/tests/baselines/reference/es2015modulekind.js index af638557fde9e..6e032e793cb05 100644 --- a/tests/baselines/reference/es2015modulekind.js +++ b/tests/baselines/reference/es2015modulekind.js @@ -1,5 +1,4 @@ //// [es2015modulekind.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es2015modulekind.symbols b/tests/baselines/reference/es2015modulekind.symbols index 8a772e318958e..fcfc1f1680f36 100644 --- a/tests/baselines/reference/es2015modulekind.symbols +++ b/tests/baselines/reference/es2015modulekind.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es2015modulekind.ts === - export default class A >A : Symbol(A, Decl(es2015modulekind.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es2015modulekind.ts, 6, 5)) +>B : Symbol(A.B, Decl(es2015modulekind.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es2015modulekind.types b/tests/baselines/reference/es2015modulekind.types index 1b09ecb0a88ba..749e30bc722da 100644 --- a/tests/baselines/reference/es2015modulekind.types +++ b/tests/baselines/reference/es2015modulekind.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es2015modulekind.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es2015modulekindWithES6Target.js b/tests/baselines/reference/es2015modulekindWithES6Target.js index b76ab2a02a22a..5f49db94b3b41 100644 --- a/tests/baselines/reference/es2015modulekindWithES6Target.js +++ b/tests/baselines/reference/es2015modulekindWithES6Target.js @@ -1,5 +1,4 @@ //// [es2015modulekindWithES6Target.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es2015modulekindWithES6Target.symbols b/tests/baselines/reference/es2015modulekindWithES6Target.symbols index 4a7c6469ca571..aaa44c84deb2b 100644 --- a/tests/baselines/reference/es2015modulekindWithES6Target.symbols +++ b/tests/baselines/reference/es2015modulekindWithES6Target.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es2015modulekindWithES6Target.ts === - export default class A >A : Symbol(A, Decl(es2015modulekindWithES6Target.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es2015modulekindWithES6Target.ts, 6, 5)) +>B : Symbol(A.B, Decl(es2015modulekindWithES6Target.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es2015modulekindWithES6Target.types b/tests/baselines/reference/es2015modulekindWithES6Target.types index 4872566b1c284..46b387f0182b6 100644 --- a/tests/baselines/reference/es2015modulekindWithES6Target.types +++ b/tests/baselines/reference/es2015modulekindWithES6Target.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es2015modulekindWithES6Target.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es2017basicAsync.js b/tests/baselines/reference/es2017basicAsync.js index d0443c1899c70..16baf6bc52615 100644 --- a/tests/baselines/reference/es2017basicAsync.js +++ b/tests/baselines/reference/es2017basicAsync.js @@ -1,5 +1,4 @@ //// [es2017basicAsync.ts] - async (): Promise => { await 0; } diff --git a/tests/baselines/reference/es2017basicAsync.symbols b/tests/baselines/reference/es2017basicAsync.symbols index fc73741ba82a6..f1957cd94e573 100644 --- a/tests/baselines/reference/es2017basicAsync.symbols +++ b/tests/baselines/reference/es2017basicAsync.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es2017basicAsync.ts === - async (): Promise => { >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) @@ -7,20 +6,20 @@ async (): Promise => { } async function asyncFunc() { ->asyncFunc : Symbol(asyncFunc, Decl(es2017basicAsync.ts, 3, 1)) +>asyncFunc : Symbol(asyncFunc, Decl(es2017basicAsync.ts, 2, 1)) await 0; } const asyncArrowFunc = async (): Promise => { ->asyncArrowFunc : Symbol(asyncArrowFunc, Decl(es2017basicAsync.ts, 9, 5)) +>asyncArrowFunc : Symbol(asyncArrowFunc, Decl(es2017basicAsync.ts, 8, 5)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 0; } async function asyncIIFE() { ->asyncIIFE : Symbol(asyncIIFE, Decl(es2017basicAsync.ts, 11, 1)) +>asyncIIFE : Symbol(asyncIIFE, Decl(es2017basicAsync.ts, 10, 1)) await 0; @@ -31,7 +30,7 @@ async function asyncIIFE() { })(); await (async function asyncNamedFunc(): Promise { ->asyncNamedFunc : Symbol(asyncNamedFunc, Decl(es2017basicAsync.ts, 20, 11)) +>asyncNamedFunc : Symbol(asyncNamedFunc, Decl(es2017basicAsync.ts, 19, 11)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 1; @@ -45,32 +44,32 @@ async function asyncIIFE() { } class AsyncClass { ->AsyncClass : Symbol(AsyncClass, Decl(es2017basicAsync.ts, 27, 1)) +>AsyncClass : Symbol(AsyncClass, Decl(es2017basicAsync.ts, 26, 1)) asyncPropFunc = async function(): Promise { ->asyncPropFunc : Symbol(AsyncClass.asyncPropFunc, Decl(es2017basicAsync.ts, 29, 18)) +>asyncPropFunc : Symbol(AsyncClass.asyncPropFunc, Decl(es2017basicAsync.ts, 28, 18)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 2; } asyncPropNamedFunc = async function namedFunc(): Promise { ->asyncPropNamedFunc : Symbol(AsyncClass.asyncPropNamedFunc, Decl(es2017basicAsync.ts, 32, 5)) ->namedFunc : Symbol(namedFunc, Decl(es2017basicAsync.ts, 34, 24)) +>asyncPropNamedFunc : Symbol(AsyncClass.asyncPropNamedFunc, Decl(es2017basicAsync.ts, 31, 5)) +>namedFunc : Symbol(namedFunc, Decl(es2017basicAsync.ts, 33, 24)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 2; } asyncPropArrowFunc = async (): Promise => { ->asyncPropArrowFunc : Symbol(AsyncClass.asyncPropArrowFunc, Decl(es2017basicAsync.ts, 36, 5)) +>asyncPropArrowFunc : Symbol(AsyncClass.asyncPropArrowFunc, Decl(es2017basicAsync.ts, 35, 5)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 2; } async asyncMethod(): Promise { ->asyncMethod : Symbol(AsyncClass.asyncMethod, Decl(es2017basicAsync.ts, 40, 5)) +>asyncMethod : Symbol(AsyncClass.asyncMethod, Decl(es2017basicAsync.ts, 39, 5)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) await 2; diff --git a/tests/baselines/reference/es2017basicAsync.types b/tests/baselines/reference/es2017basicAsync.types index 30d19cb4dfe7f..7548cdcc06ed2 100644 --- a/tests/baselines/reference/es2017basicAsync.types +++ b/tests/baselines/reference/es2017basicAsync.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es2017basicAsync.ts === - async (): Promise => { >async (): Promise => { await 0;} : () => Promise >Promise : Promise diff --git a/tests/baselines/reference/es3-amd.js b/tests/baselines/reference/es3-amd.js index ecdbfe80b46b7..caa9552c3f0ad 100644 --- a/tests/baselines/reference/es3-amd.js +++ b/tests/baselines/reference/es3-amd.js @@ -1,5 +1,4 @@ //// [es3-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es3-amd.symbols b/tests/baselines/reference/es3-amd.symbols index 1f9efe3e5900a..86af83bc8052e 100644 --- a/tests/baselines/reference/es3-amd.symbols +++ b/tests/baselines/reference/es3-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-amd.ts === - class A >A : Symbol(A, Decl(es3-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es3-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es3-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es3-amd.types b/tests/baselines/reference/es3-amd.types index 420354f364ab4..f8a501850e3b6 100644 --- a/tests/baselines/reference/es3-amd.types +++ b/tests/baselines/reference/es3-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es3-declaration-amd.js b/tests/baselines/reference/es3-declaration-amd.js index 133cf33629a70..0c447ff25b7d3 100644 --- a/tests/baselines/reference/es3-declaration-amd.js +++ b/tests/baselines/reference/es3-declaration-amd.js @@ -1,5 +1,4 @@ //// [es3-declaration-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es3-declaration-amd.symbols b/tests/baselines/reference/es3-declaration-amd.symbols index 5930b908e2fd3..537e089712385 100644 --- a/tests/baselines/reference/es3-declaration-amd.symbols +++ b/tests/baselines/reference/es3-declaration-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-declaration-amd.ts === - class A >A : Symbol(A, Decl(es3-declaration-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es3-declaration-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es3-declaration-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es3-declaration-amd.types b/tests/baselines/reference/es3-declaration-amd.types index c174d8d02557f..823c2fe1da390 100644 --- a/tests/baselines/reference/es3-declaration-amd.types +++ b/tests/baselines/reference/es3-declaration-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-declaration-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es3-jsx-preserve.js b/tests/baselines/reference/es3-jsx-preserve.js index cb1ba2a887dd8..1a1419bb8da70 100644 --- a/tests/baselines/reference/es3-jsx-preserve.js +++ b/tests/baselines/reference/es3-jsx-preserve.js @@ -1,5 +1,4 @@ //// [es3-jsx-preserve.tsx] - const React: any = null; const elem =
; diff --git a/tests/baselines/reference/es3-jsx-preserve.symbols b/tests/baselines/reference/es3-jsx-preserve.symbols index 61c9260223fd4..9083c113872ce 100644 --- a/tests/baselines/reference/es3-jsx-preserve.symbols +++ b/tests/baselines/reference/es3-jsx-preserve.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es3-jsx-preserve.tsx === - const React: any = null; ->React : Symbol(React, Decl(es3-jsx-preserve.tsx, 1, 5)) +>React : Symbol(React, Decl(es3-jsx-preserve.tsx, 0, 5)) const elem =
; ->elem : Symbol(elem, Decl(es3-jsx-preserve.tsx, 3, 5)) +>elem : Symbol(elem, Decl(es3-jsx-preserve.tsx, 2, 5)) >div : Symbol(unknown) >div : Symbol(unknown) diff --git a/tests/baselines/reference/es3-jsx-preserve.types b/tests/baselines/reference/es3-jsx-preserve.types index b37fe8af56738..759870ffac5fc 100644 --- a/tests/baselines/reference/es3-jsx-preserve.types +++ b/tests/baselines/reference/es3-jsx-preserve.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-jsx-preserve.tsx === - const React: any = null; >React : any >null : null diff --git a/tests/baselines/reference/es3-jsx-react-native.js b/tests/baselines/reference/es3-jsx-react-native.js index 08e6e25502b70..91f0ac466102e 100644 --- a/tests/baselines/reference/es3-jsx-react-native.js +++ b/tests/baselines/reference/es3-jsx-react-native.js @@ -1,5 +1,4 @@ //// [es3-jsx-react-native.tsx] - const React: any = null; const elem =
; diff --git a/tests/baselines/reference/es3-jsx-react-native.symbols b/tests/baselines/reference/es3-jsx-react-native.symbols index e7f010bd2ead0..6963318a8c5be 100644 --- a/tests/baselines/reference/es3-jsx-react-native.symbols +++ b/tests/baselines/reference/es3-jsx-react-native.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es3-jsx-react-native.tsx === - const React: any = null; ->React : Symbol(React, Decl(es3-jsx-react-native.tsx, 1, 5)) +>React : Symbol(React, Decl(es3-jsx-react-native.tsx, 0, 5)) const elem =
; ->elem : Symbol(elem, Decl(es3-jsx-react-native.tsx, 3, 5)) +>elem : Symbol(elem, Decl(es3-jsx-react-native.tsx, 2, 5)) >div : Symbol(unknown) >div : Symbol(unknown) diff --git a/tests/baselines/reference/es3-jsx-react-native.types b/tests/baselines/reference/es3-jsx-react-native.types index 1bf199606f299..7cbfbe4684f8b 100644 --- a/tests/baselines/reference/es3-jsx-react-native.types +++ b/tests/baselines/reference/es3-jsx-react-native.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-jsx-react-native.tsx === - const React: any = null; >React : any >null : null diff --git a/tests/baselines/reference/es3-jsx-react.js b/tests/baselines/reference/es3-jsx-react.js index 861dde74c86e4..39d17767a7154 100644 --- a/tests/baselines/reference/es3-jsx-react.js +++ b/tests/baselines/reference/es3-jsx-react.js @@ -1,5 +1,4 @@ //// [es3-jsx-react.tsx] - const React: any = null; const elem =
; diff --git a/tests/baselines/reference/es3-jsx-react.symbols b/tests/baselines/reference/es3-jsx-react.symbols index 465cfab7ea901..d5ebc65437cb2 100644 --- a/tests/baselines/reference/es3-jsx-react.symbols +++ b/tests/baselines/reference/es3-jsx-react.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es3-jsx-react.tsx === - const React: any = null; ->React : Symbol(React, Decl(es3-jsx-react.tsx, 1, 5)) +>React : Symbol(React, Decl(es3-jsx-react.tsx, 0, 5)) const elem =
; ->elem : Symbol(elem, Decl(es3-jsx-react.tsx, 3, 5)) +>elem : Symbol(elem, Decl(es3-jsx-react.tsx, 2, 5)) >div : Symbol(unknown) >div : Symbol(unknown) diff --git a/tests/baselines/reference/es3-jsx-react.types b/tests/baselines/reference/es3-jsx-react.types index b7734ffc1f0db..089b3ad47cb46 100644 --- a/tests/baselines/reference/es3-jsx-react.types +++ b/tests/baselines/reference/es3-jsx-react.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-jsx-react.tsx === - const React: any = null; >React : any >null : null diff --git a/tests/baselines/reference/es3-sourcemap-amd.js b/tests/baselines/reference/es3-sourcemap-amd.js index 4b16caec72182..d135a0cad7fff 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.js +++ b/tests/baselines/reference/es3-sourcemap-amd.js @@ -1,5 +1,4 @@ //// [es3-sourcemap-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es3-sourcemap-amd.js.map b/tests/baselines/reference/es3-sourcemap-amd.js.map index aa9f7aefe09de..ea5ed85a88ea8 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.js.map +++ b/tests/baselines/reference/es3-sourcemap-amd.js.map @@ -1,2 +1,2 @@ //// [es3-sourcemap-amd.js.map] -{"version":3,"file":"es3-sourcemap-amd.js","sourceRoot":"","sources":["es3-sourcemap-amd.ts"],"names":[],"mappings":"AACA;IAEI;IAGA,CAAC;IAEM,aAAC,GAAR;QAEI,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;IACL,QAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file +{"version":3,"file":"es3-sourcemap-amd.js","sourceRoot":"","sources":["es3-sourcemap-amd.ts"],"names":[],"mappings":"AAAA;IAEI;IAGA,CAAC;IAEM,aAAC,GAAR;QAEI,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;IACL,QAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file diff --git a/tests/baselines/reference/es3-sourcemap-amd.sourcemap.txt b/tests/baselines/reference/es3-sourcemap-amd.sourcemap.txt index 9cb84dff0ba9a..d3b9d665ade40 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.sourcemap.txt +++ b/tests/baselines/reference/es3-sourcemap-amd.sourcemap.txt @@ -11,9 +11,8 @@ sourceFile:es3-sourcemap-amd.ts >>>var A = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^ @@ -21,7 +20,7 @@ sourceFile:es3-sourcemap-amd.ts 1->class A >{ > -1->Emitted(2, 5) Source(4, 5) + SourceIndex(0) +1->Emitted(2, 5) Source(3, 5) + SourceIndex(0) --- >>> } 1->^^^^ @@ -32,8 +31,8 @@ sourceFile:es3-sourcemap-amd.ts > > 2 > } -1->Emitted(3, 5) Source(7, 5) + SourceIndex(0) -2 >Emitted(3, 6) Source(7, 6) + SourceIndex(0) +1->Emitted(3, 5) Source(6, 5) + SourceIndex(0) +2 >Emitted(3, 6) Source(6, 6) + SourceIndex(0) --- >>> A.prototype.B = function () { 1->^^^^ @@ -44,9 +43,9 @@ sourceFile:es3-sourcemap-amd.ts > public 2 > B 3 > -1->Emitted(4, 5) Source(9, 12) + SourceIndex(0) -2 >Emitted(4, 18) Source(9, 13) + SourceIndex(0) -3 >Emitted(4, 21) Source(9, 5) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 12) + SourceIndex(0) +2 >Emitted(4, 18) Source(8, 13) + SourceIndex(0) +3 >Emitted(4, 21) Source(8, 5) + SourceIndex(0) --- >>> return 42; 1 >^^^^^^^^ @@ -61,11 +60,11 @@ sourceFile:es3-sourcemap-amd.ts 3 > 4 > 42 5 > ; -1 >Emitted(5, 9) Source(11, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(11, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(11, 16) + SourceIndex(0) -4 >Emitted(5, 18) Source(11, 18) + SourceIndex(0) -5 >Emitted(5, 19) Source(11, 19) + SourceIndex(0) +1 >Emitted(5, 9) Source(10, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) +4 >Emitted(5, 18) Source(10, 18) + SourceIndex(0) +5 >Emitted(5, 19) Source(10, 19) + SourceIndex(0) --- >>> }; 1 >^^^^ @@ -74,8 +73,8 @@ sourceFile:es3-sourcemap-amd.ts 1 > > 2 > } -1 >Emitted(6, 5) Source(12, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(12, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) --- >>> return A; 1->^^^^ @@ -83,8 +82,8 @@ sourceFile:es3-sourcemap-amd.ts 1-> > 2 > } -1->Emitted(7, 5) Source(13, 1) + SourceIndex(0) -2 >Emitted(7, 13) Source(13, 2) + SourceIndex(0) +1->Emitted(7, 5) Source(12, 1) + SourceIndex(0) +2 >Emitted(7, 13) Source(12, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -107,9 +106,9 @@ sourceFile:es3-sourcemap-amd.ts > return 42; > } > } -1 >Emitted(8, 1) Source(13, 1) + SourceIndex(0) -2 >Emitted(8, 2) Source(13, 2) + SourceIndex(0) -3 >Emitted(8, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(8, 6) Source(13, 2) + SourceIndex(0) +1 >Emitted(8, 1) Source(12, 1) + SourceIndex(0) +2 >Emitted(8, 2) Source(12, 2) + SourceIndex(0) +3 >Emitted(8, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(8, 6) Source(12, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=es3-sourcemap-amd.js.map \ No newline at end of file diff --git a/tests/baselines/reference/es3-sourcemap-amd.symbols b/tests/baselines/reference/es3-sourcemap-amd.symbols index 919e2cfa46c22..841dd9c20ef27 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.symbols +++ b/tests/baselines/reference/es3-sourcemap-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-sourcemap-amd.ts === - class A >A : Symbol(A, Decl(es3-sourcemap-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es3-sourcemap-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es3-sourcemap-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es3-sourcemap-amd.types b/tests/baselines/reference/es3-sourcemap-amd.types index 351cbe5ded949..0970c49fe1b1a 100644 --- a/tests/baselines/reference/es3-sourcemap-amd.types +++ b/tests/baselines/reference/es3-sourcemap-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3-sourcemap-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es3defaultAliasIsQuoted.js b/tests/baselines/reference/es3defaultAliasIsQuoted.js index d3bb3d006e5f5..ea12fc7a3d62d 100644 --- a/tests/baselines/reference/es3defaultAliasIsQuoted.js +++ b/tests/baselines/reference/es3defaultAliasIsQuoted.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es3defaultAliasIsQuoted.ts] //// //// [es3defaultAliasQuoted_file0.ts] - export class Foo { static CONSTANT = "Foo"; } diff --git a/tests/baselines/reference/es3defaultAliasIsQuoted.symbols b/tests/baselines/reference/es3defaultAliasIsQuoted.symbols index 3472258373ea2..16ba6ccdcf96f 100644 --- a/tests/baselines/reference/es3defaultAliasIsQuoted.symbols +++ b/tests/baselines/reference/es3defaultAliasIsQuoted.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/es3defaultAliasQuoted_file0.ts === - export class Foo { >Foo : Symbol(Foo, Decl(es3defaultAliasQuoted_file0.ts, 0, 0)) static CONSTANT = "Foo"; ->CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 1, 18)) +>CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 0, 18)) } export default function assert(value: boolean) { ->assert : Symbol(assert, Decl(es3defaultAliasQuoted_file0.ts, 3, 1)) ->value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 5, 31)) +>assert : Symbol(assert, Decl(es3defaultAliasQuoted_file0.ts, 2, 1)) +>value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 4, 31)) if (!value) throw new Error("Assertion failed!"); ->value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 5, 31)) +>value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 4, 31)) >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } @@ -24,7 +23,7 @@ import {Foo, default as assert} from "./es3defaultAliasQuoted_file0"; assert(Foo.CONSTANT === "Foo"); >assert : Symbol(assert, Decl(es3defaultAliasQuoted_file1.ts, 0, 12)) ->Foo.CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 1, 18)) +>Foo.CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 0, 18)) >Foo : Symbol(Foo, Decl(es3defaultAliasQuoted_file1.ts, 0, 8)) ->CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 1, 18)) +>CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 0, 18)) diff --git a/tests/baselines/reference/es3defaultAliasIsQuoted.types b/tests/baselines/reference/es3defaultAliasIsQuoted.types index b041235966098..2a57d9d211fed 100644 --- a/tests/baselines/reference/es3defaultAliasIsQuoted.types +++ b/tests/baselines/reference/es3defaultAliasIsQuoted.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es3defaultAliasQuoted_file0.ts === - export class Foo { >Foo : Foo diff --git a/tests/baselines/reference/es5-amd.js b/tests/baselines/reference/es5-amd.js index ebfc5ee12d1ac..23314c78e1fed 100644 --- a/tests/baselines/reference/es5-amd.js +++ b/tests/baselines/reference/es5-amd.js @@ -1,5 +1,4 @@ //// [es5-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-amd.symbols b/tests/baselines/reference/es5-amd.symbols index 33ed9bc6423f2..21bf381ee8d4c 100644 --- a/tests/baselines/reference/es5-amd.symbols +++ b/tests/baselines/reference/es5-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-amd.ts === - class A >A : Symbol(A, Decl(es5-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-amd.types b/tests/baselines/reference/es5-amd.types index 62e47b91d1079..e86ae793256d2 100644 --- a/tests/baselines/reference/es5-amd.types +++ b/tests/baselines/reference/es5-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5-commonjs.js b/tests/baselines/reference/es5-commonjs.js index 8ebcfb01be6ec..e0f56796ef1da 100644 --- a/tests/baselines/reference/es5-commonjs.js +++ b/tests/baselines/reference/es5-commonjs.js @@ -1,5 +1,4 @@ //// [es5-commonjs.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5-commonjs.symbols b/tests/baselines/reference/es5-commonjs.symbols index a2319b14ce70c..d043f9fddc087 100644 --- a/tests/baselines/reference/es5-commonjs.symbols +++ b/tests/baselines/reference/es5-commonjs.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs.ts === - export default class A >A : Symbol(A, Decl(es5-commonjs.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es5-commonjs.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-commonjs.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-commonjs.types b/tests/baselines/reference/es5-commonjs.types index 06a14af7f4fb4..1b1fce6493c6e 100644 --- a/tests/baselines/reference/es5-commonjs.types +++ b/tests/baselines/reference/es5-commonjs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es5-commonjs2.js b/tests/baselines/reference/es5-commonjs2.js index 2c38edef6ae44..ae196be946013 100644 --- a/tests/baselines/reference/es5-commonjs2.js +++ b/tests/baselines/reference/es5-commonjs2.js @@ -1,5 +1,4 @@ //// [es5-commonjs2.ts] - export default 1; diff --git a/tests/baselines/reference/es5-commonjs2.symbols b/tests/baselines/reference/es5-commonjs2.symbols index ee57f9ad5cdad..c36026685dd02 100644 --- a/tests/baselines/reference/es5-commonjs2.symbols +++ b/tests/baselines/reference/es5-commonjs2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs2.ts === - -No type information for this code.export default 1; +export default 1; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5-commonjs2.types b/tests/baselines/reference/es5-commonjs2.types index ee57f9ad5cdad..c36026685dd02 100644 --- a/tests/baselines/reference/es5-commonjs2.types +++ b/tests/baselines/reference/es5-commonjs2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs2.ts === - -No type information for this code.export default 1; +export default 1; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5-commonjs3.errors.txt b/tests/baselines/reference/es5-commonjs3.errors.txt index fddabf56fac10..688e3dbd560fb 100644 --- a/tests/baselines/reference/es5-commonjs3.errors.txt +++ b/tests/baselines/reference/es5-commonjs3.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es5-commonjs3.ts(3,12): error TS1216: Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules. +tests/cases/compiler/es5-commonjs3.ts(2,12): error TS1216: Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules. ==== tests/cases/compiler/es5-commonjs3.ts (1 errors) ==== - export default "test"; export var __esModule = 1; ~~~~~~~~~~ diff --git a/tests/baselines/reference/es5-commonjs3.js b/tests/baselines/reference/es5-commonjs3.js index 15c11b189a3ed..8a310a108b448 100644 --- a/tests/baselines/reference/es5-commonjs3.js +++ b/tests/baselines/reference/es5-commonjs3.js @@ -1,5 +1,4 @@ //// [es5-commonjs3.ts] - export default "test"; export var __esModule = 1; diff --git a/tests/baselines/reference/es5-commonjs4.errors.txt b/tests/baselines/reference/es5-commonjs4.errors.txt index 9a901728cfb99..b51c45d5c84a7 100644 --- a/tests/baselines/reference/es5-commonjs4.errors.txt +++ b/tests/baselines/reference/es5-commonjs4.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es5-commonjs4.ts(14,12): error TS1216: Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules. +tests/cases/compiler/es5-commonjs4.ts(13,12): error TS1216: Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules. ==== tests/cases/compiler/es5-commonjs4.ts (1 errors) ==== - export default class A { constructor () diff --git a/tests/baselines/reference/es5-commonjs4.js b/tests/baselines/reference/es5-commonjs4.js index d2530d1bdf2a0..23ca56e442dc9 100644 --- a/tests/baselines/reference/es5-commonjs4.js +++ b/tests/baselines/reference/es5-commonjs4.js @@ -1,5 +1,4 @@ //// [es5-commonjs4.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5-commonjs5.js b/tests/baselines/reference/es5-commonjs5.js index bbc9bbba7c29f..bd9af7daa0d92 100644 --- a/tests/baselines/reference/es5-commonjs5.js +++ b/tests/baselines/reference/es5-commonjs5.js @@ -1,5 +1,4 @@ //// [es5-commonjs5.ts] - export default function () { return "test"; } diff --git a/tests/baselines/reference/es5-commonjs5.symbols b/tests/baselines/reference/es5-commonjs5.symbols index b134e21666834..56991d9a003c5 100644 --- a/tests/baselines/reference/es5-commonjs5.symbols +++ b/tests/baselines/reference/es5-commonjs5.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/es5-commonjs5.ts === - -No type information for this code.export default function () { +export default function () { No type information for this code. return "test"; No type information for this code.} No type information for this code. diff --git a/tests/baselines/reference/es5-commonjs5.types b/tests/baselines/reference/es5-commonjs5.types index fb72fda8c11db..29811be2f6059 100644 --- a/tests/baselines/reference/es5-commonjs5.types +++ b/tests/baselines/reference/es5-commonjs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs5.ts === - export default function () { return "test"; >"test" : "test" diff --git a/tests/baselines/reference/es5-commonjs6.js b/tests/baselines/reference/es5-commonjs6.js index 87d2f7d62a6fd..3338cbdfa473f 100644 --- a/tests/baselines/reference/es5-commonjs6.js +++ b/tests/baselines/reference/es5-commonjs6.js @@ -1,5 +1,4 @@ //// [es5-commonjs6.ts] - export default "test"; var __esModule = 1; diff --git a/tests/baselines/reference/es5-commonjs6.symbols b/tests/baselines/reference/es5-commonjs6.symbols index 7a2847e0f25e0..847ab3783f80d 100644 --- a/tests/baselines/reference/es5-commonjs6.symbols +++ b/tests/baselines/reference/es5-commonjs6.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/es5-commonjs6.ts === - export default "test"; var __esModule = 1; ->__esModule : Symbol(__esModule, Decl(es5-commonjs6.ts, 2, 3)) +>__esModule : Symbol(__esModule, Decl(es5-commonjs6.ts, 1, 3)) diff --git a/tests/baselines/reference/es5-commonjs6.types b/tests/baselines/reference/es5-commonjs6.types index cabe84e8a6974..73a16660a5619 100644 --- a/tests/baselines/reference/es5-commonjs6.types +++ b/tests/baselines/reference/es5-commonjs6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs6.ts === - export default "test"; var __esModule = 1; >__esModule : number diff --git a/tests/baselines/reference/es5-commonjs7.symbols b/tests/baselines/reference/es5-commonjs7.symbols index 14c4cc71376cc..0ac992e7db9bb 100644 --- a/tests/baselines/reference/es5-commonjs7.symbols +++ b/tests/baselines/reference/es5-commonjs7.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/test.d.ts === - export default "test"; export var __esModule; ->__esModule : Symbol(__esModule, Decl(test.d.ts, 2, 10)) +>__esModule : Symbol(__esModule, Decl(test.d.ts, 1, 10)) diff --git a/tests/baselines/reference/es5-commonjs7.types b/tests/baselines/reference/es5-commonjs7.types index e2236a61c7b92..60d9f9b6c62a9 100644 --- a/tests/baselines/reference/es5-commonjs7.types +++ b/tests/baselines/reference/es5-commonjs7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test.d.ts === - export default "test"; export var __esModule; >__esModule : any diff --git a/tests/baselines/reference/es5-commonjs8.symbols b/tests/baselines/reference/es5-commonjs8.symbols index 93041cc8b7fb3..78ffb4132492a 100644 --- a/tests/baselines/reference/es5-commonjs8.symbols +++ b/tests/baselines/reference/es5-commonjs8.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/es5-commonjs8.ts === - export default "test"; export var __esModule = 1; ->__esModule : Symbol(__esModule, Decl(es5-commonjs8.ts, 2, 10)) +>__esModule : Symbol(__esModule, Decl(es5-commonjs8.ts, 1, 10)) diff --git a/tests/baselines/reference/es5-commonjs8.types b/tests/baselines/reference/es5-commonjs8.types index be206bf5162c5..0d2196ffb96a1 100644 --- a/tests/baselines/reference/es5-commonjs8.types +++ b/tests/baselines/reference/es5-commonjs8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-commonjs8.ts === - export default "test"; export var __esModule = 1; >__esModule : number diff --git a/tests/baselines/reference/es5-declaration-amd.js b/tests/baselines/reference/es5-declaration-amd.js index 32c9690dc4ed0..618553ec0cf8d 100644 --- a/tests/baselines/reference/es5-declaration-amd.js +++ b/tests/baselines/reference/es5-declaration-amd.js @@ -1,5 +1,4 @@ //// [es5-declaration-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-declaration-amd.symbols b/tests/baselines/reference/es5-declaration-amd.symbols index 0df2ad428f031..37e7857600cb2 100644 --- a/tests/baselines/reference/es5-declaration-amd.symbols +++ b/tests/baselines/reference/es5-declaration-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-declaration-amd.ts === - class A >A : Symbol(A, Decl(es5-declaration-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-declaration-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-declaration-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-declaration-amd.types b/tests/baselines/reference/es5-declaration-amd.types index ca5422fd739b0..a71b0c39dcc74 100644 --- a/tests/baselines/reference/es5-declaration-amd.types +++ b/tests/baselines/reference/es5-declaration-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-declaration-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5-souremap-amd.js b/tests/baselines/reference/es5-souremap-amd.js index b957f605e7ccb..a4ac83a37af57 100644 --- a/tests/baselines/reference/es5-souremap-amd.js +++ b/tests/baselines/reference/es5-souremap-amd.js @@ -1,5 +1,4 @@ //// [es5-souremap-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-souremap-amd.js.map b/tests/baselines/reference/es5-souremap-amd.js.map index 4c7e152e95bc1..111d19c26fcf6 100644 --- a/tests/baselines/reference/es5-souremap-amd.js.map +++ b/tests/baselines/reference/es5-souremap-amd.js.map @@ -1,2 +1,2 @@ //// [es5-souremap-amd.js.map] -{"version":3,"file":"es5-souremap-amd.js","sourceRoot":"","sources":["es5-souremap-amd.ts"],"names":[],"mappings":"AACA;IAEI;IAGA,CAAC;IAEM,aAAC,GAAR;QAEI,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;IACL,QAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file +{"version":3,"file":"es5-souremap-amd.js","sourceRoot":"","sources":["es5-souremap-amd.ts"],"names":[],"mappings":"AAAA;IAEI;IAGA,CAAC;IAEM,aAAC,GAAR;QAEI,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;IACL,QAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file diff --git a/tests/baselines/reference/es5-souremap-amd.sourcemap.txt b/tests/baselines/reference/es5-souremap-amd.sourcemap.txt index fc573856f9c34..b57cfc577154b 100644 --- a/tests/baselines/reference/es5-souremap-amd.sourcemap.txt +++ b/tests/baselines/reference/es5-souremap-amd.sourcemap.txt @@ -11,9 +11,8 @@ sourceFile:es5-souremap-amd.ts >>>var A = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^ @@ -21,7 +20,7 @@ sourceFile:es5-souremap-amd.ts 1->class A >{ > -1->Emitted(2, 5) Source(4, 5) + SourceIndex(0) +1->Emitted(2, 5) Source(3, 5) + SourceIndex(0) --- >>> } 1->^^^^ @@ -32,8 +31,8 @@ sourceFile:es5-souremap-amd.ts > > 2 > } -1->Emitted(3, 5) Source(7, 5) + SourceIndex(0) -2 >Emitted(3, 6) Source(7, 6) + SourceIndex(0) +1->Emitted(3, 5) Source(6, 5) + SourceIndex(0) +2 >Emitted(3, 6) Source(6, 6) + SourceIndex(0) --- >>> A.prototype.B = function () { 1->^^^^ @@ -44,9 +43,9 @@ sourceFile:es5-souremap-amd.ts > public 2 > B 3 > -1->Emitted(4, 5) Source(9, 12) + SourceIndex(0) -2 >Emitted(4, 18) Source(9, 13) + SourceIndex(0) -3 >Emitted(4, 21) Source(9, 5) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 12) + SourceIndex(0) +2 >Emitted(4, 18) Source(8, 13) + SourceIndex(0) +3 >Emitted(4, 21) Source(8, 5) + SourceIndex(0) --- >>> return 42; 1 >^^^^^^^^ @@ -61,11 +60,11 @@ sourceFile:es5-souremap-amd.ts 3 > 4 > 42 5 > ; -1 >Emitted(5, 9) Source(11, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(11, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(11, 16) + SourceIndex(0) -4 >Emitted(5, 18) Source(11, 18) + SourceIndex(0) -5 >Emitted(5, 19) Source(11, 19) + SourceIndex(0) +1 >Emitted(5, 9) Source(10, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) +4 >Emitted(5, 18) Source(10, 18) + SourceIndex(0) +5 >Emitted(5, 19) Source(10, 19) + SourceIndex(0) --- >>> }; 1 >^^^^ @@ -74,8 +73,8 @@ sourceFile:es5-souremap-amd.ts 1 > > 2 > } -1 >Emitted(6, 5) Source(12, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(12, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) --- >>> return A; 1->^^^^ @@ -83,8 +82,8 @@ sourceFile:es5-souremap-amd.ts 1-> > 2 > } -1->Emitted(7, 5) Source(13, 1) + SourceIndex(0) -2 >Emitted(7, 13) Source(13, 2) + SourceIndex(0) +1->Emitted(7, 5) Source(12, 1) + SourceIndex(0) +2 >Emitted(7, 13) Source(12, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -107,9 +106,9 @@ sourceFile:es5-souremap-amd.ts > return 42; > } > } -1 >Emitted(8, 1) Source(13, 1) + SourceIndex(0) -2 >Emitted(8, 2) Source(13, 2) + SourceIndex(0) -3 >Emitted(8, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(8, 6) Source(13, 2) + SourceIndex(0) +1 >Emitted(8, 1) Source(12, 1) + SourceIndex(0) +2 >Emitted(8, 2) Source(12, 2) + SourceIndex(0) +3 >Emitted(8, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(8, 6) Source(12, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=es5-souremap-amd.js.map \ No newline at end of file diff --git a/tests/baselines/reference/es5-souremap-amd.symbols b/tests/baselines/reference/es5-souremap-amd.symbols index c725434096d3a..7ea1fbe96d8a9 100644 --- a/tests/baselines/reference/es5-souremap-amd.symbols +++ b/tests/baselines/reference/es5-souremap-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-souremap-amd.ts === - class A >A : Symbol(A, Decl(es5-souremap-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-souremap-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-souremap-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-souremap-amd.types b/tests/baselines/reference/es5-souremap-amd.types index d96f15b8d0e92..01359011456e8 100644 --- a/tests/baselines/reference/es5-souremap-amd.types +++ b/tests/baselines/reference/es5-souremap-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-souremap-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5-system.js b/tests/baselines/reference/es5-system.js index 1d59a05dcfae0..4a62c429840d4 100644 --- a/tests/baselines/reference/es5-system.js +++ b/tests/baselines/reference/es5-system.js @@ -1,5 +1,4 @@ //// [es5-system.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5-system.symbols b/tests/baselines/reference/es5-system.symbols index f2c4b38aba227..fe2c279a1e02c 100644 --- a/tests/baselines/reference/es5-system.symbols +++ b/tests/baselines/reference/es5-system.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-system.ts === - export default class A >A : Symbol(A, Decl(es5-system.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es5-system.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-system.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-system.types b/tests/baselines/reference/es5-system.types index fa6d471dbf799..79fbcc0672586 100644 --- a/tests/baselines/reference/es5-system.types +++ b/tests/baselines/reference/es5-system.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-system.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es5-system2.js b/tests/baselines/reference/es5-system2.js index 39b5e5daca288..4d793326b9b5c 100644 --- a/tests/baselines/reference/es5-system2.js +++ b/tests/baselines/reference/es5-system2.js @@ -1,5 +1,4 @@ //// [es5-system2.ts] - export var __esModule = 1; //// [es5-system2.js] diff --git a/tests/baselines/reference/es5-system2.symbols b/tests/baselines/reference/es5-system2.symbols index 2c8779b730b46..b15352701df15 100644 --- a/tests/baselines/reference/es5-system2.symbols +++ b/tests/baselines/reference/es5-system2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-system2.ts === - export var __esModule = 1; ->__esModule : Symbol(__esModule, Decl(es5-system2.ts, 1, 10)) +>__esModule : Symbol(__esModule, Decl(es5-system2.ts, 0, 10)) diff --git a/tests/baselines/reference/es5-system2.types b/tests/baselines/reference/es5-system2.types index e67258a873239..43c5425e04a3c 100644 --- a/tests/baselines/reference/es5-system2.types +++ b/tests/baselines/reference/es5-system2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-system2.ts === - export var __esModule = 1; >__esModule : number >1 : 1 diff --git a/tests/baselines/reference/es5-umd.js b/tests/baselines/reference/es5-umd.js index f98d5cde719a8..9ade8c259c02d 100644 --- a/tests/baselines/reference/es5-umd.js +++ b/tests/baselines/reference/es5-umd.js @@ -1,5 +1,4 @@ //// [es5-umd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-umd.symbols b/tests/baselines/reference/es5-umd.symbols index 73dd7ebbe5b91..3e14419f4da1d 100644 --- a/tests/baselines/reference/es5-umd.symbols +++ b/tests/baselines/reference/es5-umd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd.ts === - class A >A : Symbol(A, Decl(es5-umd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-umd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-umd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-umd.types b/tests/baselines/reference/es5-umd.types index dcee52664cce9..c64d920298c70 100644 --- a/tests/baselines/reference/es5-umd.types +++ b/tests/baselines/reference/es5-umd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5-umd2.js b/tests/baselines/reference/es5-umd2.js index b55422ca7b1a0..335c0efa925ee 100644 --- a/tests/baselines/reference/es5-umd2.js +++ b/tests/baselines/reference/es5-umd2.js @@ -1,5 +1,4 @@ //// [es5-umd2.ts] - export class A { constructor () diff --git a/tests/baselines/reference/es5-umd2.symbols b/tests/baselines/reference/es5-umd2.symbols index f017c6b72db99..9f2cda7992582 100644 --- a/tests/baselines/reference/es5-umd2.symbols +++ b/tests/baselines/reference/es5-umd2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd2.ts === - export class A >A : Symbol(A, Decl(es5-umd2.ts, 0, 0)) { @@ -9,7 +8,7 @@ export class A } public B() ->B : Symbol(A.B, Decl(es5-umd2.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-umd2.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-umd2.types b/tests/baselines/reference/es5-umd2.types index 2c24088c4a046..65ed5cca1714a 100644 --- a/tests/baselines/reference/es5-umd2.types +++ b/tests/baselines/reference/es5-umd2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd2.ts === - export class A >A : A { diff --git a/tests/baselines/reference/es5-umd3.js b/tests/baselines/reference/es5-umd3.js index 37b19ece1ac88..48f9971bdd13f 100644 --- a/tests/baselines/reference/es5-umd3.js +++ b/tests/baselines/reference/es5-umd3.js @@ -1,5 +1,4 @@ //// [es5-umd3.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5-umd3.symbols b/tests/baselines/reference/es5-umd3.symbols index ca0203b029c02..96cca79de29ac 100644 --- a/tests/baselines/reference/es5-umd3.symbols +++ b/tests/baselines/reference/es5-umd3.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd3.ts === - export default class A >A : Symbol(A, Decl(es5-umd3.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es5-umd3.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-umd3.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-umd3.types b/tests/baselines/reference/es5-umd3.types index bb4cc91af5012..235bb0af6318c 100644 --- a/tests/baselines/reference/es5-umd3.types +++ b/tests/baselines/reference/es5-umd3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd3.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es5-umd4.js b/tests/baselines/reference/es5-umd4.js index ea3cba50ac078..71fdcc6f9b9b6 100644 --- a/tests/baselines/reference/es5-umd4.js +++ b/tests/baselines/reference/es5-umd4.js @@ -1,5 +1,4 @@ //// [es5-umd4.ts] - class A { constructor () diff --git a/tests/baselines/reference/es5-umd4.symbols b/tests/baselines/reference/es5-umd4.symbols index 790c8cccb9767..3fd42895e517b 100644 --- a/tests/baselines/reference/es5-umd4.symbols +++ b/tests/baselines/reference/es5-umd4.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd4.ts === - class A >A : Symbol(A, Decl(es5-umd4.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es5-umd4.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5-umd4.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5-umd4.types b/tests/baselines/reference/es5-umd4.types index 4ce47c9e4def1..d2e38a12cc899 100644 --- a/tests/baselines/reference/es5-umd4.types +++ b/tests/baselines/reference/es5-umd4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5-umd4.ts === - class A >A : A { diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration.js b/tests/baselines/reference/es5ExportDefaultClassDeclaration.js index 25a1db0a25f4d..39fc9336e911a 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration.js +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultClassDeclaration.ts] - export default class C { method() { } } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration.symbols b/tests/baselines/reference/es5ExportDefaultClassDeclaration.symbols index 8aaa8a4e53208..2c536fa6862ce 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration.symbols +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration.ts === - export default class C { >C : Symbol(C, Decl(es5ExportDefaultClassDeclaration.ts, 0, 0)) method() { } ->method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration.ts, 1, 24)) +>method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration.ts, 0, 24)) } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration.types b/tests/baselines/reference/es5ExportDefaultClassDeclaration.types index 34fb87fcbb2bb..b7514b80bf209 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration.types +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration.ts === - export default class C { >C : C diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.js b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.js index 931eab75c72f0..fae48029e6b53 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.js +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultClassDeclaration2.ts] - export default class { method() { } } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.symbols b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.symbols index 05947d5a5572f..ceec038d5fc2d 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.symbols +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration2.ts === - export default class { method() { } ->method : Symbol(default.method, Decl(es5ExportDefaultClassDeclaration2.ts, 1, 22)) +>method : Symbol(default.method, Decl(es5ExportDefaultClassDeclaration2.ts, 0, 22)) } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.types b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.types index e4c7a59e0e740..6ab8ee26948be 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration2.types +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration2.ts === - export default class { method() { } >method : () => void diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.errors.txt b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.errors.txt index 951e8bbffd1f9..045f02e4f36ac 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.errors.txt +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es5ExportDefaultClassDeclaration3.ts(2,21): error TS2449: Class 'C' used before its declaration. +tests/cases/compiler/es5ExportDefaultClassDeclaration3.ts(1,21): error TS2449: Class 'C' used before its declaration. ==== tests/cases/compiler/es5ExportDefaultClassDeclaration3.ts (1 errors) ==== - var before: C = new C(); ~ !!! error TS2449: Class 'C' used before its declaration. diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.js b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.js index 927536114efca..5c256022032fe 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.js +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultClassDeclaration3.ts] - var before: C = new C(); export default class C { diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.symbols b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.symbols new file mode 100644 index 0000000000000..de2492da4579d --- /dev/null +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.symbols @@ -0,0 +1,29 @@ +=== tests/cases/compiler/es5ExportDefaultClassDeclaration3.ts === +var before: C = new C(); +>before : Symbol(before, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 3)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) + +export default class C { +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) + + method(): C { +>method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration3.ts, 2, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) + + return new C(); +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) + } +} + +var after: C = new C(); +>after : Symbol(after, Decl(es5ExportDefaultClassDeclaration3.ts, 8, 3)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) + +var t: typeof C = C; +>t : Symbol(t, Decl(es5ExportDefaultClassDeclaration3.ts, 10, 3)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration3.ts, 0, 24)) + + diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration3.types b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.types new file mode 100644 index 0000000000000..325a0b979181d --- /dev/null +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration3.types @@ -0,0 +1,32 @@ +=== tests/cases/compiler/es5ExportDefaultClassDeclaration3.ts === +var before: C = new C(); +>before : C +>C : C +>new C() : C +>C : typeof C + +export default class C { +>C : C + + method(): C { +>method : () => C +>C : C + + return new C(); +>new C() : C +>C : typeof C + } +} + +var after: C = new C(); +>after : C +>C : C +>new C() : C +>C : typeof C + +var t: typeof C = C; +>t : typeof C +>C : typeof C +>C : typeof C + + diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.js b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.js index 118367dd1111d..c82c96c48ce9d 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.js +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultClassDeclaration4.ts] - declare module "foo" { export var before: C; diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.symbols b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.symbols index 15faf638ca1f8..12afdf653ea91 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.symbols +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration4.ts === - declare module "foo" { export var before: C; ->before : Symbol(before, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 14)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>before : Symbol(before, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 14)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) export default class C { ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) method(): C; ->method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration4.ts, 4, 28)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>method : Symbol(C.method, Decl(es5ExportDefaultClassDeclaration4.ts, 3, 28)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) } export var after: C; ->after : Symbol(after, Decl(es5ExportDefaultClassDeclaration4.ts, 8, 14)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>after : Symbol(after, Decl(es5ExportDefaultClassDeclaration4.ts, 7, 14)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) export var t: typeof C; ->t : Symbol(t, Decl(es5ExportDefaultClassDeclaration4.ts, 10, 14)) ->C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 2, 25)) +>t : Symbol(t, Decl(es5ExportDefaultClassDeclaration4.ts, 9, 14)) +>C : Symbol(C, Decl(es5ExportDefaultClassDeclaration4.ts, 1, 25)) } diff --git a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.types b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.types index de27b4b5fb031..12a8c0b4a498a 100644 --- a/tests/baselines/reference/es5ExportDefaultClassDeclaration4.types +++ b/tests/baselines/reference/es5ExportDefaultClassDeclaration4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultClassDeclaration4.ts === - declare module "foo" { export var before: C; >before : C diff --git a/tests/baselines/reference/es5ExportDefaultExpression.js b/tests/baselines/reference/es5ExportDefaultExpression.js index 0821543134c8f..3db562da64798 100644 --- a/tests/baselines/reference/es5ExportDefaultExpression.js +++ b/tests/baselines/reference/es5ExportDefaultExpression.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultExpression.ts] - export default (1 + 2); diff --git a/tests/baselines/reference/es5ExportDefaultExpression.symbols b/tests/baselines/reference/es5ExportDefaultExpression.symbols index 3f9f11e283af5..65b2419bac96d 100644 --- a/tests/baselines/reference/es5ExportDefaultExpression.symbols +++ b/tests/baselines/reference/es5ExportDefaultExpression.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultExpression.ts === - -No type information for this code.export default (1 + 2); +export default (1 + 2); No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5ExportDefaultExpression.types b/tests/baselines/reference/es5ExportDefaultExpression.types index db4d3a3abfd8c..0184a5e56aebb 100644 --- a/tests/baselines/reference/es5ExportDefaultExpression.types +++ b/tests/baselines/reference/es5ExportDefaultExpression.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultExpression.ts === - export default (1 + 2); >(1 + 2) : number >1 + 2 : number diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.js b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.js index 068a966faa245..d834f345e50f9 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.js +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultFunctionDeclaration.ts] - export default function f() { } diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.symbols b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.symbols index 6c80a2532e3f9..5e99f51009056 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.symbols +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration.ts === - export default function f() { } >f : Symbol(f, Decl(es5ExportDefaultFunctionDeclaration.ts, 0, 0)) diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.types b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.types index 446bd8e2a3144..ee42d7200ecaa 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.types +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration.ts === - export default function f() { } >f : () => void diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.js b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.js index ab44c4cb584d1..28002494c54d1 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.js +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultFunctionDeclaration2.ts] - export default function () { } diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.symbols b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.symbols index 1b9f9d2615114..133d9b73dd426 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.symbols +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration2.ts === - -No type information for this code.export default function () { } +export default function () { } No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.types b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.types index 1b9f9d2615114..133d9b73dd426 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.types +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration2.ts === - -No type information for this code.export default function () { } +export default function () { } No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.js b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.js index c4bbcd4373e06..c4f70ae45f4e5 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.js +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultFunctionDeclaration3.ts] - var before: typeof func = func(); export default function func(): typeof func { diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.symbols b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.symbols index 921a3304e0160..644bf9e3013c7 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.symbols +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration3.ts === - var before: typeof func = func(); ->before : Symbol(before, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 3)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) +>before : Symbol(before, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 3)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) export default function func(): typeof func { ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) return func; ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) } var after: typeof func = func(); ->after : Symbol(after, Decl(es5ExportDefaultFunctionDeclaration3.ts, 7, 3)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 1, 33)) +>after : Symbol(after, Decl(es5ExportDefaultFunctionDeclaration3.ts, 6, 3)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration3.ts, 0, 33)) diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.types b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.types index d3a8ff92b2f91..7d8f15719ca08 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.types +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration3.ts === - var before: typeof func = func(); >before : () => typeof func >func : () => typeof func diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.js b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.js index a8bdc7d79ef1e..0f553adc4bda3 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.js +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultFunctionDeclaration4.ts] - declare module "bar" { var before: typeof func; diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.symbols b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.symbols index 940c095d11f67..a694dba8abef7 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.symbols +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration4.ts === - declare module "bar" { var before: typeof func; ->before : Symbol(before, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 7)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 28)) +>before : Symbol(before, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 7)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 28)) export default function func(): typeof func; ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 28)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 28)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 28)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 28)) var after: typeof func; ->after : Symbol(after, Decl(es5ExportDefaultFunctionDeclaration4.ts, 6, 7)) ->func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 2, 28)) +>after : Symbol(after, Decl(es5ExportDefaultFunctionDeclaration4.ts, 5, 7)) +>func : Symbol(func, Decl(es5ExportDefaultFunctionDeclaration4.ts, 1, 28)) } diff --git a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.types b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.types index 163311fbd1487..22961c061deee 100644 --- a/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.types +++ b/tests/baselines/reference/es5ExportDefaultFunctionDeclaration4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultFunctionDeclaration4.ts === - declare module "bar" { var before: typeof func; >before : () => typeof func diff --git a/tests/baselines/reference/es5ExportDefaultIdentifier.js b/tests/baselines/reference/es5ExportDefaultIdentifier.js index d60fba590ac13..49cddbf0677a9 100644 --- a/tests/baselines/reference/es5ExportDefaultIdentifier.js +++ b/tests/baselines/reference/es5ExportDefaultIdentifier.js @@ -1,5 +1,4 @@ //// [es5ExportDefaultIdentifier.ts] - export function f() { } export default f; diff --git a/tests/baselines/reference/es5ExportDefaultIdentifier.symbols b/tests/baselines/reference/es5ExportDefaultIdentifier.symbols index 78b9a54947ae4..7ef0a0f65ceb3 100644 --- a/tests/baselines/reference/es5ExportDefaultIdentifier.symbols +++ b/tests/baselines/reference/es5ExportDefaultIdentifier.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultIdentifier.ts === - export function f() { } >f : Symbol(f, Decl(es5ExportDefaultIdentifier.ts, 0, 0)) diff --git a/tests/baselines/reference/es5ExportDefaultIdentifier.types b/tests/baselines/reference/es5ExportDefaultIdentifier.types index d57f757507031..860a934919dfd 100644 --- a/tests/baselines/reference/es5ExportDefaultIdentifier.types +++ b/tests/baselines/reference/es5ExportDefaultIdentifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportDefaultIdentifier.ts === - export function f() { } >f : () => void diff --git a/tests/baselines/reference/es5ExportEquals.errors.txt b/tests/baselines/reference/es5ExportEquals.errors.txt index 89197aca632c0..4c57333213693 100644 --- a/tests/baselines/reference/es5ExportEquals.errors.txt +++ b/tests/baselines/reference/es5ExportEquals.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es5ExportEquals.ts(4,1): error TS2309: An export assignment cannot be used in a module with other exported elements. +tests/cases/compiler/es5ExportEquals.ts(3,1): error TS2309: An export assignment cannot be used in a module with other exported elements. ==== tests/cases/compiler/es5ExportEquals.ts (1 errors) ==== - export function f() { } export = f; diff --git a/tests/baselines/reference/es5ExportEquals.js b/tests/baselines/reference/es5ExportEquals.js index 3a1ae6fe242c2..fd9f2cc3e7719 100644 --- a/tests/baselines/reference/es5ExportEquals.js +++ b/tests/baselines/reference/es5ExportEquals.js @@ -1,5 +1,4 @@ //// [es5ExportEquals.ts] - export function f() { } export = f; diff --git a/tests/baselines/reference/es5ExportEqualsDts.js b/tests/baselines/reference/es5ExportEqualsDts.js index bc083ca075605..b8d79efef94ef 100644 --- a/tests/baselines/reference/es5ExportEqualsDts.js +++ b/tests/baselines/reference/es5ExportEqualsDts.js @@ -1,5 +1,4 @@ //// [es5ExportEqualsDts.ts] - class A { foo() { var aVal: A.B; diff --git a/tests/baselines/reference/es5ExportEqualsDts.symbols b/tests/baselines/reference/es5ExportEqualsDts.symbols index 46bc29b58dde9..0ea23053fd09e 100644 --- a/tests/baselines/reference/es5ExportEqualsDts.symbols +++ b/tests/baselines/reference/es5ExportEqualsDts.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/es5ExportEqualsDts.ts === - class A { ->A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 6, 1)) +>A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 5, 1)) foo() { ->foo : Symbol(A.foo, Decl(es5ExportEqualsDts.ts, 1, 9)) +>foo : Symbol(A.foo, Decl(es5ExportEqualsDts.ts, 0, 9)) var aVal: A.B; ->aVal : Symbol(aVal, Decl(es5ExportEqualsDts.ts, 3, 11)) ->A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 6, 1)) ->B : Symbol(A.B, Decl(es5ExportEqualsDts.ts, 8, 10)) +>aVal : Symbol(aVal, Decl(es5ExportEqualsDts.ts, 2, 11)) +>A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 5, 1)) +>B : Symbol(A.B, Decl(es5ExportEqualsDts.ts, 7, 10)) return aVal; ->aVal : Symbol(aVal, Decl(es5ExportEqualsDts.ts, 3, 11)) +>aVal : Symbol(aVal, Decl(es5ExportEqualsDts.ts, 2, 11)) } } module A { ->A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 6, 1)) +>A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 5, 1)) export interface B { } ->B : Symbol(B, Decl(es5ExportEqualsDts.ts, 8, 10)) +>B : Symbol(B, Decl(es5ExportEqualsDts.ts, 7, 10)) } export = A ->A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 6, 1)) +>A : Symbol(A, Decl(es5ExportEqualsDts.ts, 0, 0), Decl(es5ExportEqualsDts.ts, 5, 1)) diff --git a/tests/baselines/reference/es5ExportEqualsDts.types b/tests/baselines/reference/es5ExportEqualsDts.types index 265fda6c76cfb..100fc3fb93d14 100644 --- a/tests/baselines/reference/es5ExportEqualsDts.types +++ b/tests/baselines/reference/es5ExportEqualsDts.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5ExportEqualsDts.ts === - class A { >A : A diff --git a/tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt b/tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt index 936f381628d13..be6bb246c9088 100644 --- a/tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt +++ b/tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt @@ -1,3 +1,4 @@ +tests/cases/compiler/es5ModuleInternalNamedImports.ts(22,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(23,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(24,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(25,5): error TS1194: Export declarations are not permitted in a namespace. @@ -5,15 +6,13 @@ tests/cases/compiler/es5ModuleInternalNamedImports.ts(26,5): error TS1194: Expor tests/cases/compiler/es5ModuleInternalNamedImports.ts(27,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(28,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es5ModuleInternalNamedImports.ts(29,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(30,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(31,25): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(32,20): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(33,32): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/es5ModuleInternalNamedImports.ts(35,16): error TS2307: Cannot find module 'M3'. +tests/cases/compiler/es5ModuleInternalNamedImports.ts(30,25): error TS1147: Import declarations in a namespace cannot reference a module. +tests/cases/compiler/es5ModuleInternalNamedImports.ts(31,20): error TS1147: Import declarations in a namespace cannot reference a module. +tests/cases/compiler/es5ModuleInternalNamedImports.ts(32,32): error TS1147: Import declarations in a namespace cannot reference a module. +tests/cases/compiler/es5ModuleInternalNamedImports.ts(34,16): error TS2307: Cannot find module 'M3'. ==== tests/cases/compiler/es5ModuleInternalNamedImports.ts (12 errors) ==== - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es5ModuleInternalNamedImports.js b/tests/baselines/reference/es5ModuleInternalNamedImports.js index abc81b3dc94ab..74063c4348f7a 100644 --- a/tests/baselines/reference/es5ModuleInternalNamedImports.js +++ b/tests/baselines/reference/es5ModuleInternalNamedImports.js @@ -1,5 +1,4 @@ //// [es5ModuleInternalNamedImports.ts] - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es5andes6module.js b/tests/baselines/reference/es5andes6module.js index ae8c0ad87e223..bfa260eaa3ca4 100644 --- a/tests/baselines/reference/es5andes6module.js +++ b/tests/baselines/reference/es5andes6module.js @@ -1,5 +1,4 @@ //// [es5andes6module.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es5andes6module.symbols b/tests/baselines/reference/es5andes6module.symbols index 3aef923de0a82..a553c83fd2bdc 100644 --- a/tests/baselines/reference/es5andes6module.symbols +++ b/tests/baselines/reference/es5andes6module.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es5andes6module.ts === - export default class A >A : Symbol(A, Decl(es5andes6module.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es5andes6module.ts, 6, 5)) +>B : Symbol(A.B, Decl(es5andes6module.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es5andes6module.types b/tests/baselines/reference/es5andes6module.types index 44dba0eb28e9d..567b7674a454e 100644 --- a/tests/baselines/reference/es5andes6module.types +++ b/tests/baselines/reference/es5andes6module.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es5andes6module.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es6-amd.js b/tests/baselines/reference/es6-amd.js index b09f074e59f5c..a6567c64cbe25 100644 --- a/tests/baselines/reference/es6-amd.js +++ b/tests/baselines/reference/es6-amd.js @@ -1,5 +1,4 @@ //// [es6-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es6-amd.symbols b/tests/baselines/reference/es6-amd.symbols index fb9b1c57b279f..a8176b5d2a3d3 100644 --- a/tests/baselines/reference/es6-amd.symbols +++ b/tests/baselines/reference/es6-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-amd.ts === - class A >A : Symbol(A, Decl(es6-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es6-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-amd.types b/tests/baselines/reference/es6-amd.types index 5ba0315362742..c2e0d0d634f0e 100644 --- a/tests/baselines/reference/es6-amd.types +++ b/tests/baselines/reference/es6-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es6-declaration-amd.js b/tests/baselines/reference/es6-declaration-amd.js index b1f5408696953..a019dd33d6ed0 100644 --- a/tests/baselines/reference/es6-declaration-amd.js +++ b/tests/baselines/reference/es6-declaration-amd.js @@ -1,5 +1,4 @@ //// [es6-declaration-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es6-declaration-amd.symbols b/tests/baselines/reference/es6-declaration-amd.symbols index 6811dfe793d8c..be7db99662afd 100644 --- a/tests/baselines/reference/es6-declaration-amd.symbols +++ b/tests/baselines/reference/es6-declaration-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-declaration-amd.ts === - class A >A : Symbol(A, Decl(es6-declaration-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es6-declaration-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-declaration-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-declaration-amd.types b/tests/baselines/reference/es6-declaration-amd.types index 9568cedc0bde6..3bbbf6bfe183a 100644 --- a/tests/baselines/reference/es6-declaration-amd.types +++ b/tests/baselines/reference/es6-declaration-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-declaration-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es6-sourcemap-amd.js b/tests/baselines/reference/es6-sourcemap-amd.js index 106726c0f2cfb..864c1c512fc16 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.js +++ b/tests/baselines/reference/es6-sourcemap-amd.js @@ -1,5 +1,4 @@ //// [es6-sourcemap-amd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es6-sourcemap-amd.js.map b/tests/baselines/reference/es6-sourcemap-amd.js.map index d5229e3a28c24..0b8d7530c24e7 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.js.map +++ b/tests/baselines/reference/es6-sourcemap-amd.js.map @@ -1,2 +1,2 @@ //// [es6-sourcemap-amd.js.map] -{"version":3,"file":"es6-sourcemap-amd.js","sourceRoot":"","sources":["es6-sourcemap-amd.ts"],"names":[],"mappings":"AACA;IAEI;IAGA,CAAC;IAEM,CAAC;QAEJ,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;CACJ"} \ No newline at end of file +{"version":3,"file":"es6-sourcemap-amd.js","sourceRoot":"","sources":["es6-sourcemap-amd.ts"],"names":[],"mappings":"AAAA;IAEI;IAGA,CAAC;IAEM,CAAC;QAEJ,MAAM,CAAC,EAAE,CAAC;IACd,CAAC;CACJ"} \ No newline at end of file diff --git a/tests/baselines/reference/es6-sourcemap-amd.sourcemap.txt b/tests/baselines/reference/es6-sourcemap-amd.sourcemap.txt index a01507e964b23..fbc12ecf84b98 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.sourcemap.txt +++ b/tests/baselines/reference/es6-sourcemap-amd.sourcemap.txt @@ -11,9 +11,8 @@ sourceFile:es6-sourcemap-amd.ts >>>class A { 1 > 2 >^^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> constructor() { 1->^^^^ @@ -21,7 +20,7 @@ sourceFile:es6-sourcemap-amd.ts 1->class A >{ > -1->Emitted(2, 5) Source(4, 5) + SourceIndex(0) +1->Emitted(2, 5) Source(3, 5) + SourceIndex(0) --- >>> } 1->^^^^ @@ -32,8 +31,8 @@ sourceFile:es6-sourcemap-amd.ts > > 2 > } -1->Emitted(3, 5) Source(7, 5) + SourceIndex(0) -2 >Emitted(3, 6) Source(7, 6) + SourceIndex(0) +1->Emitted(3, 5) Source(6, 5) + SourceIndex(0) +2 >Emitted(3, 6) Source(6, 6) + SourceIndex(0) --- >>> B() { 1->^^^^ @@ -43,8 +42,8 @@ sourceFile:es6-sourcemap-amd.ts > > public 2 > B -1->Emitted(4, 5) Source(9, 12) + SourceIndex(0) -2 >Emitted(4, 6) Source(9, 13) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 12) + SourceIndex(0) +2 >Emitted(4, 6) Source(8, 13) + SourceIndex(0) --- >>> return 42; 1->^^^^^^^^ @@ -59,11 +58,11 @@ sourceFile:es6-sourcemap-amd.ts 3 > 4 > 42 5 > ; -1->Emitted(5, 9) Source(11, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(11, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(11, 16) + SourceIndex(0) -4 >Emitted(5, 18) Source(11, 18) + SourceIndex(0) -5 >Emitted(5, 19) Source(11, 19) + SourceIndex(0) +1->Emitted(5, 9) Source(10, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) +4 >Emitted(5, 18) Source(10, 18) + SourceIndex(0) +5 >Emitted(5, 19) Source(10, 19) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -71,14 +70,14 @@ sourceFile:es6-sourcemap-amd.ts 1 > > 2 > } -1 >Emitted(6, 5) Source(12, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(12, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) --- >>>} 1 >^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > >} -1 >Emitted(7, 2) Source(13, 2) + SourceIndex(0) +1 >Emitted(7, 2) Source(12, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=es6-sourcemap-amd.js.map \ No newline at end of file diff --git a/tests/baselines/reference/es6-sourcemap-amd.symbols b/tests/baselines/reference/es6-sourcemap-amd.symbols index e5f731234f340..2ca5f4fa6ac57 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.symbols +++ b/tests/baselines/reference/es6-sourcemap-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-sourcemap-amd.ts === - class A >A : Symbol(A, Decl(es6-sourcemap-amd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es6-sourcemap-amd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-sourcemap-amd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-sourcemap-amd.types b/tests/baselines/reference/es6-sourcemap-amd.types index 6cbdc98df6fc0..c83f1f54e39a1 100644 --- a/tests/baselines/reference/es6-sourcemap-amd.types +++ b/tests/baselines/reference/es6-sourcemap-amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-sourcemap-amd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es6-umd.js b/tests/baselines/reference/es6-umd.js index af8159eeb3e42..0caa8525bfb47 100644 --- a/tests/baselines/reference/es6-umd.js +++ b/tests/baselines/reference/es6-umd.js @@ -1,5 +1,4 @@ //// [es6-umd.ts] - class A { constructor () diff --git a/tests/baselines/reference/es6-umd.symbols b/tests/baselines/reference/es6-umd.symbols index 50584887fb3b5..986f63f826c26 100644 --- a/tests/baselines/reference/es6-umd.symbols +++ b/tests/baselines/reference/es6-umd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-umd.ts === - class A >A : Symbol(A, Decl(es6-umd.ts, 0, 0)) { @@ -9,7 +8,7 @@ class A } public B() ->B : Symbol(A.B, Decl(es6-umd.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-umd.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-umd.types b/tests/baselines/reference/es6-umd.types index ed3932d2e2a18..621eea8112c71 100644 --- a/tests/baselines/reference/es6-umd.types +++ b/tests/baselines/reference/es6-umd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-umd.ts === - class A >A : A { diff --git a/tests/baselines/reference/es6-umd2.js b/tests/baselines/reference/es6-umd2.js index c0707b869cc04..dcccb24d51168 100644 --- a/tests/baselines/reference/es6-umd2.js +++ b/tests/baselines/reference/es6-umd2.js @@ -1,5 +1,4 @@ //// [es6-umd2.ts] - export class A { constructor () diff --git a/tests/baselines/reference/es6-umd2.symbols b/tests/baselines/reference/es6-umd2.symbols index d998e4b68ee97..e4a5c976a7eac 100644 --- a/tests/baselines/reference/es6-umd2.symbols +++ b/tests/baselines/reference/es6-umd2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-umd2.ts === - export class A >A : Symbol(A, Decl(es6-umd2.ts, 0, 0)) { @@ -9,7 +8,7 @@ export class A } public B() ->B : Symbol(A.B, Decl(es6-umd2.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6-umd2.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6-umd2.types b/tests/baselines/reference/es6-umd2.types index 395f136add828..9ab3dedd7cf15 100644 --- a/tests/baselines/reference/es6-umd2.types +++ b/tests/baselines/reference/es6-umd2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6-umd2.ts === - export class A >A : A { diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.js b/tests/baselines/reference/es6ClassSuperCodegenBug.js index 1945726d2185e..95b4adb25ee51 100644 --- a/tests/baselines/reference/es6ClassSuperCodegenBug.js +++ b/tests/baselines/reference/es6ClassSuperCodegenBug.js @@ -1,5 +1,4 @@ //// [es6ClassSuperCodegenBug.ts] - class A { constructor(str1:string, str2:string) {} } diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.symbols b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols index bb500a1d2c286..d520ec3ceb1c3 100644 --- a/tests/baselines/reference/es6ClassSuperCodegenBug.symbols +++ b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/es6ClassSuperCodegenBug.ts === - class A { >A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0)) constructor(str1:string, str2:string) {} ->str1 : Symbol(str1, Decl(es6ClassSuperCodegenBug.ts, 2, 13)) ->str2 : Symbol(str2, Decl(es6ClassSuperCodegenBug.ts, 2, 25)) +>str1 : Symbol(str1, Decl(es6ClassSuperCodegenBug.ts, 1, 13)) +>str2 : Symbol(str2, Decl(es6ClassSuperCodegenBug.ts, 1, 25)) } class B extends A { ->B : Symbol(B, Decl(es6ClassSuperCodegenBug.ts, 3, 1)) +>B : Symbol(B, Decl(es6ClassSuperCodegenBug.ts, 2, 1)) >A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0)) constructor() { diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.types b/tests/baselines/reference/es6ClassSuperCodegenBug.types index d98b1fea451c7..b454ead3f6fa9 100644 --- a/tests/baselines/reference/es6ClassSuperCodegenBug.types +++ b/tests/baselines/reference/es6ClassSuperCodegenBug.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ClassSuperCodegenBug.ts === - class A { >A : A diff --git a/tests/baselines/reference/es6ExportAll.js b/tests/baselines/reference/es6ExportAll.js index afa07c39d8ff9..9149bcfa2e7b8 100644 --- a/tests/baselines/reference/es6ExportAll.js +++ b/tests/baselines/reference/es6ExportAll.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAll.ts] //// //// [server.ts] - export class c { } export interface i { diff --git a/tests/baselines/reference/es6ExportAll.symbols b/tests/baselines/reference/es6ExportAll.symbols index c2a575f5e5c0b..d0890d99e3d8d 100644 --- a/tests/baselines/reference/es6ExportAll.symbols +++ b/tests/baselines/reference/es6ExportAll.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/server.ts === - export class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } export interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } export module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } export var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 10)) +>x : Symbol(x, Decl(server.ts, 7, 10)) export module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 18)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 18)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ExportAll.types b/tests/baselines/reference/es6ExportAll.types index b6a7056fd4add..e3a012135e028 100644 --- a/tests/baselines/reference/es6ExportAll.types +++ b/tests/baselines/reference/es6ExportAll.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { >c : c } diff --git a/tests/baselines/reference/es6ExportAllInEs5.js b/tests/baselines/reference/es6ExportAllInEs5.js index 91910ba26163c..6b1b1c82354d3 100644 --- a/tests/baselines/reference/es6ExportAllInEs5.js +++ b/tests/baselines/reference/es6ExportAllInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAllInEs5.ts] //// //// [server.ts] - export class c { } export interface i { diff --git a/tests/baselines/reference/es6ExportAllInEs5.symbols b/tests/baselines/reference/es6ExportAllInEs5.symbols index 26d47f63af3d1..2a2ad20f22fa6 100644 --- a/tests/baselines/reference/es6ExportAllInEs5.symbols +++ b/tests/baselines/reference/es6ExportAllInEs5.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/server.ts === - export class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } export interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } export module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } export var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 10)) +>x : Symbol(x, Decl(server.ts, 7, 10)) export module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 18)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 18)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ExportAllInEs5.types b/tests/baselines/reference/es6ExportAllInEs5.types index fc3daf6685c3f..fc465785493a1 100644 --- a/tests/baselines/reference/es6ExportAllInEs5.types +++ b/tests/baselines/reference/es6ExportAllInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { >c : c } diff --git a/tests/baselines/reference/es6ExportAssignment.errors.txt b/tests/baselines/reference/es6ExportAssignment.errors.txt index be5ad734c8618..55a150f47add0 100644 --- a/tests/baselines/reference/es6ExportAssignment.errors.txt +++ b/tests/baselines/reference/es6ExportAssignment.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es6ExportAssignment.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/es6ExportAssignment.ts(2,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/es6ExportAssignment.ts (1 errors) ==== - var a = 10; export = a; ~~~~~~~~~~~ diff --git a/tests/baselines/reference/es6ExportAssignment.js b/tests/baselines/reference/es6ExportAssignment.js index 4a4e0368bb7e8..3d0198901ef3c 100644 --- a/tests/baselines/reference/es6ExportAssignment.js +++ b/tests/baselines/reference/es6ExportAssignment.js @@ -1,5 +1,4 @@ //// [es6ExportAssignment.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ExportAssignment2.errors.txt b/tests/baselines/reference/es6ExportAssignment2.errors.txt index 490d586759138..9065f9ba6cee9 100644 --- a/tests/baselines/reference/es6ExportAssignment2.errors.txt +++ b/tests/baselines/reference/es6ExportAssignment2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/a.ts(2,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/a.ts (1 errors) ==== - var a = 10; export = a; // Error: export = not allowed in ES6 ~~~~~~~~~~~ diff --git a/tests/baselines/reference/es6ExportAssignment2.js b/tests/baselines/reference/es6ExportAssignment2.js index f038f71d494e6..531c9e5a5ba3d 100644 --- a/tests/baselines/reference/es6ExportAssignment2.js +++ b/tests/baselines/reference/es6ExportAssignment2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAssignment2.ts] //// //// [a.ts] - var a = 10; export = a; // Error: export = not allowed in ES6 diff --git a/tests/baselines/reference/es6ExportAssignment3.js b/tests/baselines/reference/es6ExportAssignment3.js index 1a25ee94023a5..5a2cd208a5a7e 100644 --- a/tests/baselines/reference/es6ExportAssignment3.js +++ b/tests/baselines/reference/es6ExportAssignment3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAssignment3.ts] //// //// [a.d.ts] - declare var a: number; export = a; // OK, in ambient context diff --git a/tests/baselines/reference/es6ExportAssignment3.symbols b/tests/baselines/reference/es6ExportAssignment3.symbols index 73346cdc4b87c..40a7a1108dac2 100644 --- a/tests/baselines/reference/es6ExportAssignment3.symbols +++ b/tests/baselines/reference/es6ExportAssignment3.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/a.d.ts === - declare var a: number; ->a : Symbol(a, Decl(a.d.ts, 1, 11)) +>a : Symbol(a, Decl(a.d.ts, 0, 11)) export = a; // OK, in ambient context ->a : Symbol(a, Decl(a.d.ts, 1, 11)) +>a : Symbol(a, Decl(a.d.ts, 0, 11)) === tests/cases/compiler/b.ts === import * as a from "a"; diff --git a/tests/baselines/reference/es6ExportAssignment3.types b/tests/baselines/reference/es6ExportAssignment3.types index 84f896c301ddb..91901d68c48c5 100644 --- a/tests/baselines/reference/es6ExportAssignment3.types +++ b/tests/baselines/reference/es6ExportAssignment3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.d.ts === - declare var a: number; >a : number diff --git a/tests/baselines/reference/es6ExportAssignment4.js b/tests/baselines/reference/es6ExportAssignment4.js index a06aa4d49de26..656dcc0729f77 100644 --- a/tests/baselines/reference/es6ExportAssignment4.js +++ b/tests/baselines/reference/es6ExportAssignment4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportAssignment4.ts] //// //// [modules.d.ts] - declare module "a" { var a: number; export = a; // OK, in ambient context diff --git a/tests/baselines/reference/es6ExportAssignment4.symbols b/tests/baselines/reference/es6ExportAssignment4.symbols index 42d4a9d009fcc..099892c706e9c 100644 --- a/tests/baselines/reference/es6ExportAssignment4.symbols +++ b/tests/baselines/reference/es6ExportAssignment4.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modules.d.ts === - declare module "a" { var a: number; ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) export = a; // OK, in ambient context ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) } === tests/cases/compiler/b.ts === diff --git a/tests/baselines/reference/es6ExportAssignment4.types b/tests/baselines/reference/es6ExportAssignment4.types index c32bc14ec9064..e42fadc294431 100644 --- a/tests/baselines/reference/es6ExportAssignment4.types +++ b/tests/baselines/reference/es6ExportAssignment4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modules.d.ts === - declare module "a" { var a: number; >a : number diff --git a/tests/baselines/reference/es6ExportClause.js b/tests/baselines/reference/es6ExportClause.js index 742a39e1324e2..3c4a17f3812a2 100644 --- a/tests/baselines/reference/es6ExportClause.js +++ b/tests/baselines/reference/es6ExportClause.js @@ -1,5 +1,4 @@ //// [server.ts] - class c { } interface i { diff --git a/tests/baselines/reference/es6ExportClause.symbols b/tests/baselines/reference/es6ExportClause.symbols index 1bacedec76c0f..428b0b4448b51 100644 --- a/tests/baselines/reference/es6ExportClause.symbols +++ b/tests/baselines/reference/es6ExportClause.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/server.ts === - class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 3)) +>x : Symbol(x, Decl(server.ts, 7, 3)) module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 11)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 11)) } export { c }; ->c : Symbol(c, Decl(server.ts, 11, 8)) +>c : Symbol(c, Decl(server.ts, 10, 8)) export { c as c2 }; ->c : Symbol(c2, Decl(server.ts, 12, 8)) ->c2 : Symbol(c2, Decl(server.ts, 12, 8)) +>c : Symbol(c2, Decl(server.ts, 11, 8)) +>c2 : Symbol(c2, Decl(server.ts, 11, 8)) export { i, m as instantiatedModule }; ->i : Symbol(i, Decl(server.ts, 13, 8)) ->m : Symbol(instantiatedModule, Decl(server.ts, 13, 11)) ->instantiatedModule : Symbol(instantiatedModule, Decl(server.ts, 13, 11)) +>i : Symbol(i, Decl(server.ts, 12, 8)) +>m : Symbol(instantiatedModule, Decl(server.ts, 12, 11)) +>instantiatedModule : Symbol(instantiatedModule, Decl(server.ts, 12, 11)) export { uninstantiated }; ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 14, 8)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 13, 8)) export { x }; ->x : Symbol(x, Decl(server.ts, 15, 8)) +>x : Symbol(x, Decl(server.ts, 14, 8)) diff --git a/tests/baselines/reference/es6ExportClause.types b/tests/baselines/reference/es6ExportClause.types index 22e5f9c0e0d9c..8cc9187cff0a8 100644 --- a/tests/baselines/reference/es6ExportClause.types +++ b/tests/baselines/reference/es6ExportClause.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class c { >c : c } diff --git a/tests/baselines/reference/es6ExportClauseInEs5.js b/tests/baselines/reference/es6ExportClauseInEs5.js index 3d3625aad18d7..d6d44fe8b2b55 100644 --- a/tests/baselines/reference/es6ExportClauseInEs5.js +++ b/tests/baselines/reference/es6ExportClauseInEs5.js @@ -1,5 +1,4 @@ //// [server.ts] - class c { } interface i { diff --git a/tests/baselines/reference/es6ExportClauseInEs5.symbols b/tests/baselines/reference/es6ExportClauseInEs5.symbols index 1bacedec76c0f..428b0b4448b51 100644 --- a/tests/baselines/reference/es6ExportClauseInEs5.symbols +++ b/tests/baselines/reference/es6ExportClauseInEs5.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/server.ts === - class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 3)) +>x : Symbol(x, Decl(server.ts, 7, 3)) module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 11)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 11)) } export { c }; ->c : Symbol(c, Decl(server.ts, 11, 8)) +>c : Symbol(c, Decl(server.ts, 10, 8)) export { c as c2 }; ->c : Symbol(c2, Decl(server.ts, 12, 8)) ->c2 : Symbol(c2, Decl(server.ts, 12, 8)) +>c : Symbol(c2, Decl(server.ts, 11, 8)) +>c2 : Symbol(c2, Decl(server.ts, 11, 8)) export { i, m as instantiatedModule }; ->i : Symbol(i, Decl(server.ts, 13, 8)) ->m : Symbol(instantiatedModule, Decl(server.ts, 13, 11)) ->instantiatedModule : Symbol(instantiatedModule, Decl(server.ts, 13, 11)) +>i : Symbol(i, Decl(server.ts, 12, 8)) +>m : Symbol(instantiatedModule, Decl(server.ts, 12, 11)) +>instantiatedModule : Symbol(instantiatedModule, Decl(server.ts, 12, 11)) export { uninstantiated }; ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 14, 8)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 13, 8)) export { x }; ->x : Symbol(x, Decl(server.ts, 15, 8)) +>x : Symbol(x, Decl(server.ts, 14, 8)) diff --git a/tests/baselines/reference/es6ExportClauseInEs5.types b/tests/baselines/reference/es6ExportClauseInEs5.types index 22e5f9c0e0d9c..8cc9187cff0a8 100644 --- a/tests/baselines/reference/es6ExportClauseInEs5.types +++ b/tests/baselines/reference/es6ExportClauseInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class c { >c : c } diff --git a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.js b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.js index d8aa8e607e358..8d76534e67709 100644 --- a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.js +++ b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.js @@ -1,5 +1,4 @@ //// [server.ts] - var foo = 2; foo = 3; diff --git a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.symbols b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.symbols index 6f8dbb01ec587..27c40ea5bbe8f 100644 --- a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.symbols +++ b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.symbols @@ -1,40 +1,39 @@ === tests/cases/compiler/server.ts === - var foo = 2; ->foo : Symbol(foo, Decl(server.ts, 1, 3)) +>foo : Symbol(foo, Decl(server.ts, 0, 3)) foo = 3; ->foo : Symbol(foo, Decl(server.ts, 1, 3)) +>foo : Symbol(foo, Decl(server.ts, 0, 3)) var baz = 3; ->baz : Symbol(baz, Decl(server.ts, 4, 3)) +>baz : Symbol(baz, Decl(server.ts, 3, 3)) baz = 4; ->baz : Symbol(baz, Decl(server.ts, 4, 3)) +>baz : Symbol(baz, Decl(server.ts, 3, 3)) var buzz = 10; ->buzz : Symbol(buzz, Decl(server.ts, 7, 3)) +>buzz : Symbol(buzz, Decl(server.ts, 6, 3)) buzz += 3; ->buzz : Symbol(buzz, Decl(server.ts, 7, 3)) +>buzz : Symbol(buzz, Decl(server.ts, 6, 3)) var bizz = 8; ->bizz : Symbol(bizz, Decl(server.ts, 10, 3)) +>bizz : Symbol(bizz, Decl(server.ts, 9, 3)) bizz++; // compiles to exports.bizz = bizz += 1 ->bizz : Symbol(bizz, Decl(server.ts, 10, 3)) +>bizz : Symbol(bizz, Decl(server.ts, 9, 3)) bizz--; // similarly ->bizz : Symbol(bizz, Decl(server.ts, 10, 3)) +>bizz : Symbol(bizz, Decl(server.ts, 9, 3)) ++bizz; // compiles to exports.bizz = ++bizz ->bizz : Symbol(bizz, Decl(server.ts, 10, 3)) +>bizz : Symbol(bizz, Decl(server.ts, 9, 3)) export { foo, baz, baz as quux, buzz, bizz }; ->foo : Symbol(foo, Decl(server.ts, 15, 8)) ->baz : Symbol(baz, Decl(server.ts, 15, 13)) ->baz : Symbol(quux, Decl(server.ts, 15, 18)) ->quux : Symbol(quux, Decl(server.ts, 15, 18)) ->buzz : Symbol(buzz, Decl(server.ts, 15, 31)) ->bizz : Symbol(bizz, Decl(server.ts, 15, 37)) +>foo : Symbol(foo, Decl(server.ts, 14, 8)) +>baz : Symbol(baz, Decl(server.ts, 14, 13)) +>baz : Symbol(quux, Decl(server.ts, 14, 18)) +>quux : Symbol(quux, Decl(server.ts, 14, 18)) +>buzz : Symbol(buzz, Decl(server.ts, 14, 31)) +>bizz : Symbol(bizz, Decl(server.ts, 14, 37)) diff --git a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.types b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.types index f846063c7efa6..ece6e7b90a845 100644 --- a/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.types +++ b/tests/baselines/reference/es6ExportClauseWithAssignmentInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - var foo = 2; >foo : number >2 : 2 diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.js b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.js index ccdd32d99c0ad..9fda5910fccc1 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.js +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportClauseWithoutModuleSpecifier.ts] //// //// [server.ts] - export class c { } export interface i { diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.symbols b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.symbols index 731a0fdcc30c2..5103e803104ba 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.symbols +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/server.ts === - export class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } export interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } export module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } export var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 10)) +>x : Symbol(x, Decl(server.ts, 7, 10)) export module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 18)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 18)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types index 748f731f91822..abb1c3b69e22e 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { >c : c } diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.js b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.js index ecfccd5d84379..d9b31f4edbbf5 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.js +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportClauseWithoutModuleSpecifierInEs5.ts] //// //// [server.ts] - export class c { } export interface i { diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.symbols b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.symbols index c8e279e65bf1f..a69f038d077a5 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.symbols +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/server.ts === - export class c { >c : Symbol(c, Decl(server.ts, 0, 0)) } export interface i { ->i : Symbol(i, Decl(server.ts, 2, 1)) +>i : Symbol(i, Decl(server.ts, 1, 1)) } export module m { ->m : Symbol(m, Decl(server.ts, 4, 1)) +>m : Symbol(m, Decl(server.ts, 3, 1)) export var x = 10; ->x : Symbol(x, Decl(server.ts, 6, 14)) +>x : Symbol(x, Decl(server.ts, 5, 14)) } export var x = 10; ->x : Symbol(x, Decl(server.ts, 8, 10)) +>x : Symbol(x, Decl(server.ts, 7, 10)) export module uninstantiated { ->uninstantiated : Symbol(uninstantiated, Decl(server.ts, 8, 18)) +>uninstantiated : Symbol(uninstantiated, Decl(server.ts, 7, 18)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types index 496717c3a85d7..b407d9b16f5d8 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { >c : c } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration.js b/tests/baselines/reference/es6ExportDefaultClassDeclaration.js index 8162d6813b6b2..0d1de55af6386 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration.js +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultClassDeclaration.ts] - export default class C { method() { } } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration.symbols b/tests/baselines/reference/es6ExportDefaultClassDeclaration.symbols index 3e5ce34c7d76c..e7676339df645 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration.symbols +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/es6ExportDefaultClassDeclaration.ts === - export default class C { >C : Symbol(C, Decl(es6ExportDefaultClassDeclaration.ts, 0, 0)) method() { } ->method : Symbol(C.method, Decl(es6ExportDefaultClassDeclaration.ts, 1, 24)) +>method : Symbol(C.method, Decl(es6ExportDefaultClassDeclaration.ts, 0, 24)) } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration.types b/tests/baselines/reference/es6ExportDefaultClassDeclaration.types index 59e74fc1257c5..2cd5c9e4d3188 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration.types +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultClassDeclaration.ts === - export default class C { >C : C diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.js b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.js index e2f8524fb06d9..3b7cb476dfdcc 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.js +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultClassDeclaration2.ts] - export default class { method() { } } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.symbols b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.symbols index a52c754c581dd..6bd008ce2df59 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.symbols +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ExportDefaultClassDeclaration2.ts === - export default class { method() { } ->method : Symbol(default.method, Decl(es6ExportDefaultClassDeclaration2.ts, 1, 22)) +>method : Symbol(default.method, Decl(es6ExportDefaultClassDeclaration2.ts, 0, 22)) } diff --git a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.types b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.types index 513cacf05e4d0..2723190fddf71 100644 --- a/tests/baselines/reference/es6ExportDefaultClassDeclaration2.types +++ b/tests/baselines/reference/es6ExportDefaultClassDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultClassDeclaration2.ts === - export default class { method() { } >method : () => void diff --git a/tests/baselines/reference/es6ExportDefaultExpression.js b/tests/baselines/reference/es6ExportDefaultExpression.js index 100182b9f289a..ce6dcd71b905f 100644 --- a/tests/baselines/reference/es6ExportDefaultExpression.js +++ b/tests/baselines/reference/es6ExportDefaultExpression.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultExpression.ts] - export default (1 + 2); diff --git a/tests/baselines/reference/es6ExportDefaultExpression.symbols b/tests/baselines/reference/es6ExportDefaultExpression.symbols index f80acc12900ca..b5d3549a1f694 100644 --- a/tests/baselines/reference/es6ExportDefaultExpression.symbols +++ b/tests/baselines/reference/es6ExportDefaultExpression.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultExpression.ts === - -No type information for this code.export default (1 + 2); +export default (1 + 2); No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es6ExportDefaultExpression.types b/tests/baselines/reference/es6ExportDefaultExpression.types index 1e6a38482b692..8228dba1cf58c 100644 --- a/tests/baselines/reference/es6ExportDefaultExpression.types +++ b/tests/baselines/reference/es6ExportDefaultExpression.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultExpression.ts === - export default (1 + 2); >(1 + 2) : number >1 + 2 : number diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.js b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.js index a30c8d7103950..7ddb52cd6d02b 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.js +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultFunctionDeclaration.ts] - export default function f() { } diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.symbols b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.symbols index 4050ac975455b..47cc63cdd5d68 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.symbols +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultFunctionDeclaration.ts === - export default function f() { } >f : Symbol(f, Decl(es6ExportDefaultFunctionDeclaration.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.types b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.types index 6179bde9613aa..cf6c5ca5b46b0 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.types +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultFunctionDeclaration.ts === - export default function f() { } >f : () => void diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.js b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.js index 46ed72dd23686..dc2713f8f143e 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.js +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultFunctionDeclaration2.ts] - export default function () { } diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.symbols b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.symbols index 3cb2fc9b1cd0c..4021dbdc49a34 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.symbols +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultFunctionDeclaration2.ts === - -No type information for this code.export default function () { } +export default function () { } No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.types b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.types index 3cb2fc9b1cd0c..4021dbdc49a34 100644 --- a/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.types +++ b/tests/baselines/reference/es6ExportDefaultFunctionDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultFunctionDeclaration2.ts === - -No type information for this code.export default function () { } +export default function () { } No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/es6ExportDefaultIdentifier.js b/tests/baselines/reference/es6ExportDefaultIdentifier.js index 1fd3a38ff8d91..8f2e39fa1710d 100644 --- a/tests/baselines/reference/es6ExportDefaultIdentifier.js +++ b/tests/baselines/reference/es6ExportDefaultIdentifier.js @@ -1,5 +1,4 @@ //// [es6ExportDefaultIdentifier.ts] - export function f() { } export default f; diff --git a/tests/baselines/reference/es6ExportDefaultIdentifier.symbols b/tests/baselines/reference/es6ExportDefaultIdentifier.symbols index 29b932aaeda92..96e7a601922b9 100644 --- a/tests/baselines/reference/es6ExportDefaultIdentifier.symbols +++ b/tests/baselines/reference/es6ExportDefaultIdentifier.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultIdentifier.ts === - export function f() { } >f : Symbol(f, Decl(es6ExportDefaultIdentifier.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ExportDefaultIdentifier.types b/tests/baselines/reference/es6ExportDefaultIdentifier.types index 81dc168efd0cf..2e6264fd250ed 100644 --- a/tests/baselines/reference/es6ExportDefaultIdentifier.types +++ b/tests/baselines/reference/es6ExportDefaultIdentifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ExportDefaultIdentifier.ts === - export function f() { } >f : () => void diff --git a/tests/baselines/reference/es6ExportEquals.errors.txt b/tests/baselines/reference/es6ExportEquals.errors.txt index 8a6c6ceef3787..fa6e8519918b8 100644 --- a/tests/baselines/reference/es6ExportEquals.errors.txt +++ b/tests/baselines/reference/es6ExportEquals.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/es6ExportEquals.ts(4,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. -tests/cases/compiler/es6ExportEquals.ts(4,1): error TS2309: An export assignment cannot be used in a module with other exported elements. +tests/cases/compiler/es6ExportEquals.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/es6ExportEquals.ts(3,1): error TS2309: An export assignment cannot be used in a module with other exported elements. ==== tests/cases/compiler/es6ExportEquals.ts (2 errors) ==== - export function f() { } export = f; diff --git a/tests/baselines/reference/es6ExportEquals.js b/tests/baselines/reference/es6ExportEquals.js index e4cf13758ffd2..99cae1c5a7341 100644 --- a/tests/baselines/reference/es6ExportEquals.js +++ b/tests/baselines/reference/es6ExportEquals.js @@ -1,5 +1,4 @@ //// [es6ExportEquals.ts] - export function f() { } export = f; diff --git a/tests/baselines/reference/es6ExportEqualsInterop.errors.txt b/tests/baselines/reference/es6ExportEqualsInterop.errors.txt index be9aaf35fc440..4a9f7dcb50669 100644 --- a/tests/baselines/reference/es6ExportEqualsInterop.errors.txt +++ b/tests/baselines/reference/es6ExportEqualsInterop.errors.txt @@ -205,7 +205,6 @@ tests/cases/compiler/main.ts(106,15): error TS2498: Module '"class-module"' uses !!! error TS2498: Module '"class-module"' uses 'export =' and cannot be used with 'export *'. ==== tests/cases/compiler/modules.d.ts (0 errors) ==== - declare module "interface" { interface Foo { x: number; diff --git a/tests/baselines/reference/es6ExportEqualsInterop.js b/tests/baselines/reference/es6ExportEqualsInterop.js index d1f8de5faa710..5e04221df8b8f 100644 --- a/tests/baselines/reference/es6ExportEqualsInterop.js +++ b/tests/baselines/reference/es6ExportEqualsInterop.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ExportEqualsInterop.ts] //// //// [modules.d.ts] - declare module "interface" { interface Foo { x: number; @@ -208,8 +207,8 @@ export * from "class-module"; //// [main.js] -/// "use strict"; +/// function __export(m) { for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; } diff --git a/tests/baselines/reference/es6ImportDefaultBinding.js b/tests/baselines/reference/es6ImportDefaultBinding.js index 2798d025894ba..5629c9b8cdc63 100644 --- a/tests/baselines/reference/es6ImportDefaultBinding.js +++ b/tests/baselines/reference/es6ImportDefaultBinding.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBinding.ts] //// //// [es6ImportDefaultBinding_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBinding.symbols b/tests/baselines/reference/es6ImportDefaultBinding.symbols index d1e76d7075acc..66f05f9267e89 100644 --- a/tests/baselines/reference/es6ImportDefaultBinding.symbols +++ b/tests/baselines/reference/es6ImportDefaultBinding.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportDefaultBinding_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBinding_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBinding_0.ts, 0, 3)) export default a; ->a : Symbol(a, Decl(es6ImportDefaultBinding_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBinding_0.ts, 0, 3)) === tests/cases/compiler/es6ImportDefaultBinding_1.ts === import defaultBinding from "es6ImportDefaultBinding_0"; diff --git a/tests/baselines/reference/es6ImportDefaultBinding.types b/tests/baselines/reference/es6ImportDefaultBinding.types index f538ee8127bae..a93fa91f1c8d7 100644 --- a/tests/baselines/reference/es6ImportDefaultBinding.types +++ b/tests/baselines/reference/es6ImportDefaultBinding.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBinding_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingAmd.js b/tests/baselines/reference/es6ImportDefaultBindingAmd.js index 977b94f879031..d8a13efa2d6ab 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingAmd.js +++ b/tests/baselines/reference/es6ImportDefaultBindingAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingAmd.ts] //// //// [es6ImportDefaultBindingAmd_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingAmd.symbols b/tests/baselines/reference/es6ImportDefaultBindingAmd.symbols index cab731104bd3d..a370a72911331 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingAmd.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingAmd.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportDefaultBindingAmd_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBindingAmd_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingAmd_0.ts, 0, 3)) export default a; ->a : Symbol(a, Decl(es6ImportDefaultBindingAmd_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingAmd_0.ts, 0, 3)) === tests/cases/compiler/es6ImportDefaultBindingAmd_1.ts === import defaultBinding from "es6ImportDefaultBindingAmd_0"; diff --git a/tests/baselines/reference/es6ImportDefaultBindingAmd.types b/tests/baselines/reference/es6ImportDefaultBindingAmd.types index 824c5568b17c2..8ce878a1c9225 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingAmd.types +++ b/tests/baselines/reference/es6ImportDefaultBindingAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBindingAmd_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingDts.js b/tests/baselines/reference/es6ImportDefaultBindingDts.js index 94b824a3766b8..55df3a8e98ed7 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingDts.js +++ b/tests/baselines/reference/es6ImportDefaultBindingDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingDts.ts] //// //// [server.ts] - class c { } export default c; diff --git a/tests/baselines/reference/es6ImportDefaultBindingDts.symbols b/tests/baselines/reference/es6ImportDefaultBindingDts.symbols index f25be3eacad19..3465cdd318caa 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingDts.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingDts.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class c { } >c : Symbol(c, Decl(server.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ImportDefaultBindingDts.types b/tests/baselines/reference/es6ImportDefaultBindingDts.types index 8543c6845b2b4..31d4904cf8137 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingDts.types +++ b/tests/baselines/reference/es6ImportDefaultBindingDts.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class c { } >c : c diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js index 8335a1953de0e..bccb0a9dea4e6 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport.ts] //// //// [es6ImportDefaultBindingFollowedWithNamedImport_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols index 5da138f6c6242..b7e713f29d3cb 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 0, 10)) export var x = a; ->x : Symbol(x, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 2, 10)) ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) +>x : Symbol(x, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 0, 10)) export var m = a; ->m : Symbol(m, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 3, 10)) ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) +>m : Symbol(m, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 0, 10)) export default {}; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types index 0fba9c6390c7d..fb48d53778f2d 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.errors.txt index 21f488e9ca581..86900c03bbe1e 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1_1.ts(11,27) ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1_0.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.js index 755af6f4fdb85..54a4d4346068b 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1.ts] //// //// [es6ImportDefaultBindingFollowedWithNamedImport1_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.errors.txt index c62ecb70c58d0..5649b5c2ed052 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1InEs5_1.ts(1 ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1InEs5_0.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.js index 8eb76b487f8db..46e52a43135f1 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.ts] //// //// [es6ImportDefaultBindingFollowedWithNamedImport1InEs5_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.errors.txt index 97c66a179601a..6acc3edc77e89 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.errors.txt @@ -19,7 +19,6 @@ tests/cases/compiler/client.ts(12,12): error TS2323: Cannot redeclare exported v ==== tests/cases/compiler/server.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.js index d72751c7610bd..02c093987d4fa 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.ts] //// //// [server.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.errors.txt index 47e0cb347f34e..57621079e291e 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/client.ts(11,8): error TS1192: Module '"tests/cases/compile ==== tests/cases/compiler/server.ts (0 errors) ==== - export class a { } export class x { } export class m { } diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.js index 5bf268709d38a..0809a5278f0c6 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportDts.ts] //// //// [server.ts] - export class a { } export class x { } export class m { } diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.errors.txt index e939398632c37..b078d0abfe3a3 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/client.ts(11,27): error TS2305: Module '"tests/cases/compil ==== tests/cases/compiler/server.ts (0 errors) ==== - class a { } export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.js index 307dcc92f4668..cf0219ce1c749 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportDts1.ts] //// //// [server.ts] - class a { } export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.errors.txt index 7c5080241f180..c6735211e6e35 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportInEs5_1.ts(11 ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportInEs5_0.ts (0 errors) ==== - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.js index 2e9d8104a39c4..90875ff58788e 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportInEs5.ts] //// //// [es6ImportDefaultBindingFollowedWithNamedImportInEs5_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.errors.txt index 859fe59b47f98..57ef30e3c0012 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.errors.txt @@ -13,7 +13,6 @@ tests/cases/compiler/client.ts(12,12): error TS2323: Cannot redeclare exported v ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.js index 77266084bda3c..756ae6a999bc8 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImportWithExport.ts] //// //// [server.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.errors.txt index eb28020ca9ebf..4cf81cfc8048f 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_1.ts(1, ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_1.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.js index 2b24fda075559..4fbac48bd36a6 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding.ts] //// //// [es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts] - export var a = 10; //// [es6ImportDefaultBindingFollowedWithNamespaceBinding_1.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.js index a732cf9ec0a93..eb90b4882b0da 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding1.ts] //// //// [es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.symbols b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.symbols index a62cdfec87310..2eae4503db5ec 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts, 0, 3)) export default a; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts, 0, 3)) === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_1.ts === import defaultBinding, * as nameSpaceBinding from "es6ImportDefaultBindingFollowedWithNamespaceBinding_0"; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.types b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.types index a97100c662c7e..4cc93acc6bb06 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.types +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.js index c1c419689341f..a6217abb784ed 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.ts] //// //// [es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.symbols b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.symbols index 4262dd3c61b7c..dec550cc914b7 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts, 0, 3)) export default a; ->a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts, 0, 3)) === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_1.ts === import defaultBinding, * as nameSpaceBinding from "./es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0"; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.types b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.types index 18dc5efe22664..dca293b535cb4 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.types +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1InEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.errors.txt index f738abc9bc1de..236c98d02f742 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/client.ts(1,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.js index b82fb9aeee96f..2e5ce8ebc0bf4 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.ts] //// //// [server.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.errors.txt index 1fc12619017cb..ac986c630046c 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/client.ts(1,8): error TS1192: Module '"tests/cases/compiler ==== tests/cases/compiler/server.ts (0 errors) ==== - export class a { } ==== tests/cases/compiler/client.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.js index 8d033c6953626..b153fb042eb6c 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.ts] //// //// [server.ts] - export class a { } //// [client.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.js index c488db3e88e52..41140c71646d2 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.ts] //// //// [server.ts] - class a { } export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.symbols b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.symbols index 28f1e4cc4d73d..655f5828a87a8 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.symbols +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class a { } >a : Symbol(a, Decl(server.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.types b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.types index 990bae10af6d3..33cc7c1530170 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.types +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - class a { } >a : a diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.errors.txt index f14af87315cb3..d3d0f1c1c6e07 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_1. ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_1.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.js index 0db21dfd064ea..5586054319ad0 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.ts] //// //// [es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_0.ts] - export var a = 10; //// [es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5_1.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.errors.txt index d0eee52735650..526bf9a03e028 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/client.ts(1,15): error TS1192: Module '"tests/cases/compile ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/client.ts (2 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.js index 96720294a8af9..ded9e2811a270 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.ts] //// //// [server.ts] - export var a = 10; //// [client.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingInEs5.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingInEs5.errors.txt index 18f634d7b73de..604b27fd9c2b6 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingInEs5.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingInEs5.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/es6ImportDefaultBindingInEs5_1.ts(1,8): error TS1192: Modul ==== tests/cases/compiler/es6ImportDefaultBindingInEs5_0.ts (0 errors) ==== - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingInEs5.js b/tests/baselines/reference/es6ImportDefaultBindingInEs5.js index f6ea834811830..165f58b924650 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingInEs5.js +++ b/tests/baselines/reference/es6ImportDefaultBindingInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingInEs5.ts] //// //// [es6ImportDefaultBindingInEs5_0.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.errors.txt index 87311d3557c75..d6235f446cf59 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.errors.txt @@ -4,7 +4,6 @@ tests/cases/compiler/es6ImportDefaultBindingMergeErrors_1.ts(8,8): error TS2300: ==== tests/cases/compiler/es6ImportDefaultBindingMergeErrors_0.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.js b/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.js index 4c51a54462d65..85f3d34cd6781 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.js +++ b/tests/baselines/reference/es6ImportDefaultBindingMergeErrors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingMergeErrors.ts] //// //// [es6ImportDefaultBindingMergeErrors_0.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.errors.txt index 9d0e46ceb97c3..11c9c0af1409e 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/es6ImportDefaultBindingNoDefaultProperty_1.ts(1,8): error T ==== tests/cases/compiler/es6ImportDefaultBindingNoDefaultProperty_0.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/es6ImportDefaultBindingNoDefaultProperty_1.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.js b/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.js index e294c08befa7e..0b233910696c7 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.js +++ b/tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingNoDefaultProperty.ts] //// //// [es6ImportDefaultBindingNoDefaultProperty_0.ts] - export var a = 10; //// [es6ImportDefaultBindingNoDefaultProperty_1.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingWithExport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingWithExport.errors.txt index 1bd24e8492662..c39d34a2ef452 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportDefaultBindingWithExport.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/client.ts(3,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportDefaultBindingWithExport.js b/tests/baselines/reference/es6ImportDefaultBindingWithExport.js index a9f760f127869..38b391ac6d315 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingWithExport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportDefaultBindingWithExport.ts] //// //// [server.ts] - var a = 10; export default a; diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt b/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt index fa0d9dc834add..37870a2a366ed 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt +++ b/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/client.ts(1,1): error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. -tests/cases/compiler/server.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/server.ts(2,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/client.ts (1 errors) ==== @@ -7,7 +7,6 @@ tests/cases/compiler/server.ts(3,1): error TS1203: Export assignment cannot be u ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. ==== tests/cases/compiler/server.ts (1 errors) ==== - var a = 10; export = a; ~~~~~~~~~~~ diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration.js b/tests/baselines/reference/es6ImportEqualsDeclaration.js index 5195bdc631b30..1ca0e94cf8aa9 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration.js +++ b/tests/baselines/reference/es6ImportEqualsDeclaration.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportEqualsDeclaration.ts] //// //// [server.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration2.js b/tests/baselines/reference/es6ImportEqualsDeclaration2.js index c7a009a17cf9e..cc6d33a9afa4c 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration2.js +++ b/tests/baselines/reference/es6ImportEqualsDeclaration2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportEqualsDeclaration2.ts] //// //// [server.d.ts] - declare module "other" { export class C { } } diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration2.symbols b/tests/baselines/reference/es6ImportEqualsDeclaration2.symbols index a7c556f5be041..d751025baf36e 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration2.symbols +++ b/tests/baselines/reference/es6ImportEqualsDeclaration2.symbols @@ -1,23 +1,22 @@ === tests/cases/compiler/server.d.ts === - declare module "other" { export class C { } ->C : Symbol(C, Decl(server.d.ts, 1, 24)) +>C : Symbol(C, Decl(server.d.ts, 0, 24)) } declare module "server" { import events = require("other"); // Ambient declaration, no error expected. ->events : Symbol(events, Decl(server.d.ts, 5, 25)) +>events : Symbol(events, Decl(server.d.ts, 4, 25)) module S { ->S : Symbol(S, Decl(server.d.ts, 6, 37)) +>S : Symbol(S, Decl(server.d.ts, 5, 37)) export var a: number; ->a : Symbol(a, Decl(server.d.ts, 9, 18)) +>a : Symbol(a, Decl(server.d.ts, 8, 18)) } export = S; // Ambient declaration, no error expected. ->S : Symbol(S, Decl(server.d.ts, 6, 37)) +>S : Symbol(S, Decl(server.d.ts, 5, 37)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration2.types b/tests/baselines/reference/es6ImportEqualsDeclaration2.types index a483d10f25c60..93d47a330d66b 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration2.types +++ b/tests/baselines/reference/es6ImportEqualsDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.d.ts === - declare module "other" { export class C { } >C : C diff --git a/tests/baselines/reference/es6ImportNameSpaceImport.js b/tests/baselines/reference/es6ImportNameSpaceImport.js index b5296d15f9bef..c9013259e8ead 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImport.js +++ b/tests/baselines/reference/es6ImportNameSpaceImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImport.ts] //// //// [es6ImportNameSpaceImport_0.ts] - export var a = 10; //// [es6ImportNameSpaceImport_1.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImport.symbols b/tests/baselines/reference/es6ImportNameSpaceImport.symbols index add2b792d4916..12bd21cf3df10 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImport.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImport.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportNameSpaceImport_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNameSpaceImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNameSpaceImport_0.ts, 0, 10)) === tests/cases/compiler/es6ImportNameSpaceImport_1.ts === import * as nameSpaceBinding from "./es6ImportNameSpaceImport_0"; @@ -9,9 +8,9 @@ import * as nameSpaceBinding from "./es6ImportNameSpaceImport_0"; var x = nameSpaceBinding.a; >x : Symbol(x, Decl(es6ImportNameSpaceImport_1.ts, 1, 3)) ->nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImport_0.ts, 1, 10)) +>nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImport_0.ts, 0, 10)) >nameSpaceBinding : Symbol(nameSpaceBinding, Decl(es6ImportNameSpaceImport_1.ts, 0, 6)) ->a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImport_0.ts, 1, 10)) +>a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImport_0.ts, 0, 10)) import * as nameSpaceBinding2 from "./es6ImportNameSpaceImport_0"; // elide this >nameSpaceBinding2 : Symbol(nameSpaceBinding2, Decl(es6ImportNameSpaceImport_1.ts, 2, 6)) diff --git a/tests/baselines/reference/es6ImportNameSpaceImport.types b/tests/baselines/reference/es6ImportNameSpaceImport.types index 6b73fb90bce99..51d1ae69a32c4 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImport.types +++ b/tests/baselines/reference/es6ImportNameSpaceImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNameSpaceImport_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNameSpaceImportAmd.js b/tests/baselines/reference/es6ImportNameSpaceImportAmd.js index 200f49a298655..44a0635f7a2db 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportAmd.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportAmd.ts] //// //// [es6ImportNameSpaceImportAmd_0.ts] - export var a = 10; //// [es6ImportNameSpaceImportAmd_1.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImportAmd.symbols b/tests/baselines/reference/es6ImportNameSpaceImportAmd.symbols index 24c67cd6f4753..0a8fa16191d03 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportAmd.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImportAmd.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportNameSpaceImportAmd_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNameSpaceImportAmd_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNameSpaceImportAmd_0.ts, 0, 10)) === tests/cases/compiler/es6ImportNameSpaceImportAmd_1.ts === import * as nameSpaceBinding from "es6ImportNameSpaceImportAmd_0"; @@ -9,9 +8,9 @@ import * as nameSpaceBinding from "es6ImportNameSpaceImportAmd_0"; var x = nameSpaceBinding.a; >x : Symbol(x, Decl(es6ImportNameSpaceImportAmd_1.ts, 1, 3)) ->nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportAmd_0.ts, 1, 10)) +>nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportAmd_0.ts, 0, 10)) >nameSpaceBinding : Symbol(nameSpaceBinding, Decl(es6ImportNameSpaceImportAmd_1.ts, 0, 6)) ->a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportAmd_0.ts, 1, 10)) +>a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportAmd_0.ts, 0, 10)) import * as nameSpaceBinding2 from "es6ImportNameSpaceImportAmd_0"; // elide this >nameSpaceBinding2 : Symbol(nameSpaceBinding2, Decl(es6ImportNameSpaceImportAmd_1.ts, 2, 6)) diff --git a/tests/baselines/reference/es6ImportNameSpaceImportAmd.types b/tests/baselines/reference/es6ImportNameSpaceImportAmd.types index 96cd4e603eaa3..f11f90fd6a85e 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportAmd.types +++ b/tests/baselines/reference/es6ImportNameSpaceImportAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNameSpaceImportAmd_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNameSpaceImportDts.js b/tests/baselines/reference/es6ImportNameSpaceImportDts.js index cae90885ce21d..d57f881de91ad 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportDts.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportDts.ts] //// //// [server.ts] - export class c { }; //// [client.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImportDts.symbols b/tests/baselines/reference/es6ImportNameSpaceImportDts.symbols index 5f6fea374bed0..6426da0933c91 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportDts.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImportDts.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { }; >c : Symbol(c, Decl(server.ts, 0, 0)) diff --git a/tests/baselines/reference/es6ImportNameSpaceImportDts.types b/tests/baselines/reference/es6ImportNameSpaceImportDts.types index e49f3ace57a1d..5a1916191ffe6 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportDts.types +++ b/tests/baselines/reference/es6ImportNameSpaceImportDts.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class c { }; >c : c diff --git a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.js b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.js index ee00df9a2cc55..1eced8142cb8d 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportInEs5.ts] //// //// [es6ImportNameSpaceImportInEs5_0.ts] - export var a = 10; //// [es6ImportNameSpaceImportInEs5_1.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.symbols b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.symbols index 7be619dcc7e69..7239d5f46fdcb 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportNameSpaceImportInEs5_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 0, 10)) === tests/cases/compiler/es6ImportNameSpaceImportInEs5_1.ts === import * as nameSpaceBinding from "./es6ImportNameSpaceImportInEs5_0"; @@ -9,9 +8,9 @@ import * as nameSpaceBinding from "./es6ImportNameSpaceImportInEs5_0"; var x = nameSpaceBinding.a; >x : Symbol(x, Decl(es6ImportNameSpaceImportInEs5_1.ts, 1, 3)) ->nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 1, 10)) +>nameSpaceBinding.a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 0, 10)) >nameSpaceBinding : Symbol(nameSpaceBinding, Decl(es6ImportNameSpaceImportInEs5_1.ts, 0, 6)) ->a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 1, 10)) +>a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImportInEs5_0.ts, 0, 10)) import * as nameSpaceBinding2 from "./es6ImportNameSpaceImportInEs5_0"; // elide this >nameSpaceBinding2 : Symbol(nameSpaceBinding2, Decl(es6ImportNameSpaceImportInEs5_1.ts, 2, 6)) diff --git a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.types b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.types index 81971078849a1..647535cf51bbf 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportInEs5.types +++ b/tests/baselines/reference/es6ImportNameSpaceImportInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNameSpaceImportInEs5_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.errors.txt b/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.errors.txt index de9ba69653226..e73061ef152c1 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.errors.txt +++ b/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.errors.txt @@ -4,7 +4,6 @@ tests/cases/compiler/es6ImportNameSpaceImportMergeErrors_1.ts(7,8): error TS2440 ==== tests/cases/compiler/es6ImportNameSpaceImportMergeErrors_0.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/es6ImportNameSpaceImportMergeErrors_1.ts (3 errors) ==== diff --git a/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.js b/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.js index 39594102007ba..1a41e265e7dfc 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportMergeErrors.ts] //// //// [es6ImportNameSpaceImportMergeErrors_0.ts] - export var a = 10; //// [es6ImportNameSpaceImportMergeErrors_1.ts] diff --git a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.js b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.js index 0276c44f8ab49..760a4a9682818 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportNoNamedExports.ts] //// //// [es6ImportNameSpaceImportNoNamedExports_0.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.symbols b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.symbols index 8767c1a4add9e..f37e1f7014bd1 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.symbols +++ b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportNameSpaceImportNoNamedExports_0.ts === - var a = 10; ->a : Symbol(a, Decl(es6ImportNameSpaceImportNoNamedExports_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportNameSpaceImportNoNamedExports_0.ts, 0, 3)) export = a; ->a : Symbol(a, Decl(es6ImportNameSpaceImportNoNamedExports_0.ts, 1, 3)) +>a : Symbol(a, Decl(es6ImportNameSpaceImportNoNamedExports_0.ts, 0, 3)) === tests/cases/compiler/es6ImportNameSpaceImportNoNamedExports_1.ts === import * as nameSpaceBinding from "./es6ImportNameSpaceImportNoNamedExports_0"; // error diff --git a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.types b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.types index 041100c76782c..f8f97e01ef37b 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.types +++ b/tests/baselines/reference/es6ImportNameSpaceImportNoNamedExports.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNameSpaceImportNoNamedExports_0.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNameSpaceImportWithExport.errors.txt b/tests/baselines/reference/es6ImportNameSpaceImportWithExport.errors.txt index 901556e73bd73..eac060e59685c 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportNameSpaceImportWithExport.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/client.ts(3,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/client.ts (2 errors) ==== diff --git a/tests/baselines/reference/es6ImportNameSpaceImportWithExport.js b/tests/baselines/reference/es6ImportNameSpaceImportWithExport.js index 3c8b40f550e06..57aa0cf0c05c3 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImportWithExport.js +++ b/tests/baselines/reference/es6ImportNameSpaceImportWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNameSpaceImportWithExport.ts] //// //// [server.ts] - export var a = 10; //// [client.ts] diff --git a/tests/baselines/reference/es6ImportNamedImport.js b/tests/baselines/reference/es6ImportNamedImport.js index a9fcb861ec510..92e56660cc781 100644 --- a/tests/baselines/reference/es6ImportNamedImport.js +++ b/tests/baselines/reference/es6ImportNamedImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImport.ts] //// //// [es6ImportNamedImport_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImport.symbols b/tests/baselines/reference/es6ImportNamedImport.symbols index 0d30db6113fe4..10a1b79be54c5 100644 --- a/tests/baselines/reference/es6ImportNamedImport.symbols +++ b/tests/baselines/reference/es6ImportNamedImport.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/es6ImportNamedImport_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 0, 10)) export var x = a; ->x : Symbol(x, Decl(es6ImportNamedImport_0.ts, 2, 10)) ->a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 1, 10)) +>x : Symbol(x, Decl(es6ImportNamedImport_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 0, 10)) export var m = a; ->m : Symbol(m, Decl(es6ImportNamedImport_0.ts, 3, 10)) ->a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 1, 10)) +>m : Symbol(m, Decl(es6ImportNamedImport_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 0, 10)) export var a1 = 10; ->a1 : Symbol(a1, Decl(es6ImportNamedImport_0.ts, 4, 10)) +>a1 : Symbol(a1, Decl(es6ImportNamedImport_0.ts, 3, 10)) export var x1 = 10; ->x1 : Symbol(x1, Decl(es6ImportNamedImport_0.ts, 5, 10)) +>x1 : Symbol(x1, Decl(es6ImportNamedImport_0.ts, 4, 10)) export var z1 = 10; ->z1 : Symbol(z1, Decl(es6ImportNamedImport_0.ts, 6, 10)) +>z1 : Symbol(z1, Decl(es6ImportNamedImport_0.ts, 5, 10)) export var z2 = 10; ->z2 : Symbol(z2, Decl(es6ImportNamedImport_0.ts, 7, 10)) +>z2 : Symbol(z2, Decl(es6ImportNamedImport_0.ts, 6, 10)) export var aaaa = 10; ->aaaa : Symbol(aaaa, Decl(es6ImportNamedImport_0.ts, 8, 10)) +>aaaa : Symbol(aaaa, Decl(es6ImportNamedImport_0.ts, 7, 10)) === tests/cases/compiler/es6ImportNamedImport_1.ts === import { } from "./es6ImportNamedImport_0"; diff --git a/tests/baselines/reference/es6ImportNamedImport.types b/tests/baselines/reference/es6ImportNamedImport.types index 0ac3789c5e0a7..1172e1e08508f 100644 --- a/tests/baselines/reference/es6ImportNamedImport.types +++ b/tests/baselines/reference/es6ImportNamedImport.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImport_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNamedImportAmd.js b/tests/baselines/reference/es6ImportNamedImportAmd.js index bd6213f259fc5..8f1a7cb013b2f 100644 --- a/tests/baselines/reference/es6ImportNamedImportAmd.js +++ b/tests/baselines/reference/es6ImportNamedImportAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportAmd.ts] //// //// [es6ImportNamedImportAmd_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportAmd.symbols b/tests/baselines/reference/es6ImportNamedImportAmd.symbols index 2feaf603f4082..1a50a0ccf959b 100644 --- a/tests/baselines/reference/es6ImportNamedImportAmd.symbols +++ b/tests/baselines/reference/es6ImportNamedImportAmd.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/es6ImportNamedImportAmd_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 0, 10)) export var x = a; ->x : Symbol(x, Decl(es6ImportNamedImportAmd_0.ts, 2, 10)) ->a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 1, 10)) +>x : Symbol(x, Decl(es6ImportNamedImportAmd_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 0, 10)) export var m = a; ->m : Symbol(m, Decl(es6ImportNamedImportAmd_0.ts, 3, 10)) ->a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 1, 10)) +>m : Symbol(m, Decl(es6ImportNamedImportAmd_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportAmd_0.ts, 0, 10)) export var a1 = 10; ->a1 : Symbol(a1, Decl(es6ImportNamedImportAmd_0.ts, 4, 10)) +>a1 : Symbol(a1, Decl(es6ImportNamedImportAmd_0.ts, 3, 10)) export var x1 = 10; ->x1 : Symbol(x1, Decl(es6ImportNamedImportAmd_0.ts, 5, 10)) +>x1 : Symbol(x1, Decl(es6ImportNamedImportAmd_0.ts, 4, 10)) export var z1 = 10; ->z1 : Symbol(z1, Decl(es6ImportNamedImportAmd_0.ts, 6, 10)) +>z1 : Symbol(z1, Decl(es6ImportNamedImportAmd_0.ts, 5, 10)) export var z2 = 10; ->z2 : Symbol(z2, Decl(es6ImportNamedImportAmd_0.ts, 7, 10)) +>z2 : Symbol(z2, Decl(es6ImportNamedImportAmd_0.ts, 6, 10)) export var aaaa = 10; ->aaaa : Symbol(aaaa, Decl(es6ImportNamedImportAmd_0.ts, 8, 10)) +>aaaa : Symbol(aaaa, Decl(es6ImportNamedImportAmd_0.ts, 7, 10)) === tests/cases/compiler/es6ImportNamedImportAmd_1.ts === import { } from "es6ImportNamedImportAmd_0"; diff --git a/tests/baselines/reference/es6ImportNamedImportAmd.types b/tests/baselines/reference/es6ImportNamedImportAmd.types index 897187a5a0db0..a987fda53fd7d 100644 --- a/tests/baselines/reference/es6ImportNamedImportAmd.types +++ b/tests/baselines/reference/es6ImportNamedImportAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImportAmd_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNamedImportDts.js b/tests/baselines/reference/es6ImportNamedImportDts.js index d68ffd794a728..0ce09d4b180bf 100644 --- a/tests/baselines/reference/es6ImportNamedImportDts.js +++ b/tests/baselines/reference/es6ImportNamedImportDts.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportDts.ts] //// //// [server.ts] - export class a { } export class a11 { } export class a12 { } diff --git a/tests/baselines/reference/es6ImportNamedImportDts.symbols b/tests/baselines/reference/es6ImportNamedImportDts.symbols index dab2e13d0f60d..88e22bec1b51b 100644 --- a/tests/baselines/reference/es6ImportNamedImportDts.symbols +++ b/tests/baselines/reference/es6ImportNamedImportDts.symbols @@ -1,46 +1,45 @@ === tests/cases/compiler/server.ts === - export class a { } >a : Symbol(a, Decl(server.ts, 0, 0)) export class a11 { } ->a11 : Symbol(a11, Decl(server.ts, 1, 18)) +>a11 : Symbol(a11, Decl(server.ts, 0, 18)) export class a12 { } ->a12 : Symbol(a12, Decl(server.ts, 2, 20)) +>a12 : Symbol(a12, Decl(server.ts, 1, 20)) export class x { } ->x : Symbol(x, Decl(server.ts, 3, 20)) +>x : Symbol(x, Decl(server.ts, 2, 20)) export class x11 { } ->x11 : Symbol(x11, Decl(server.ts, 4, 18)) +>x11 : Symbol(x11, Decl(server.ts, 3, 18)) export class m { } ->m : Symbol(m, Decl(server.ts, 5, 20)) +>m : Symbol(m, Decl(server.ts, 4, 20)) export class a1 { } ->a1 : Symbol(a1, Decl(server.ts, 6, 18)) +>a1 : Symbol(a1, Decl(server.ts, 5, 18)) export class x1 { } ->x1 : Symbol(x1, Decl(server.ts, 7, 19)) +>x1 : Symbol(x1, Decl(server.ts, 6, 19)) export class a111 { } ->a111 : Symbol(a111, Decl(server.ts, 8, 19)) +>a111 : Symbol(a111, Decl(server.ts, 7, 19)) export class x111 { } ->x111 : Symbol(x111, Decl(server.ts, 9, 21)) +>x111 : Symbol(x111, Decl(server.ts, 8, 21)) export class z1 { } ->z1 : Symbol(z1, Decl(server.ts, 10, 21)) +>z1 : Symbol(z1, Decl(server.ts, 9, 21)) export class z2 { } ->z2 : Symbol(z2, Decl(server.ts, 11, 19)) +>z2 : Symbol(z2, Decl(server.ts, 10, 19)) export class aaaa { } ->aaaa : Symbol(aaaa, Decl(server.ts, 12, 19)) +>aaaa : Symbol(aaaa, Decl(server.ts, 11, 19)) export class aaaa1 { } ->aaaa1 : Symbol(aaaa1, Decl(server.ts, 13, 21)) +>aaaa1 : Symbol(aaaa1, Decl(server.ts, 12, 21)) === tests/cases/compiler/client.ts === import { } from "./server"; diff --git a/tests/baselines/reference/es6ImportNamedImportDts.types b/tests/baselines/reference/es6ImportNamedImportDts.types index 9aba1012117cb..d30d147bf805b 100644 --- a/tests/baselines/reference/es6ImportNamedImportDts.types +++ b/tests/baselines/reference/es6ImportNamedImportDts.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export class a { } >a : a diff --git a/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.errors.txt b/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.errors.txt index cb0a5caff8d09..34a33ccab9708 100644 --- a/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.errors.txt @@ -1,20 +1,19 @@ -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,10): error TS2300: Duplicate identifier 'yield'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,23): error TS2307: Cannot find module 'somemodule'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,10): error TS1003: Identifier expected. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,10): error TS2300: Duplicate identifier 'default'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,25): error TS2307: Cannot find module 'somemodule'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(4,19): error TS1003: Identifier expected. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(4,19): error TS2300: Duplicate identifier 'default'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(1,10): error TS2300: Duplicate identifier 'yield'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(1,23): error TS2307: Cannot find module 'somemodule'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,10): error TS1003: Identifier expected. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,10): error TS2300: Duplicate identifier 'default'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(2,25): error TS2307: Cannot find module 'somemodule'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,19): error TS1003: Identifier expected. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,19): error TS2300: Duplicate identifier 'default'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(3,34): error TS2307: Cannot find module 'somemodule'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(4,21): error TS2300: Duplicate identifier 'yield'. tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(4,34): error TS2307: Cannot find module 'somemodule'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,21): error TS2300: Duplicate identifier 'yield'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,34): error TS2307: Cannot find module 'somemodule'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(6,21): error TS1003: Identifier expected. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(6,21): error TS2300: Duplicate identifier 'default'. -tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(6,36): error TS2307: Cannot find module 'somemodule'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,21): error TS1003: Identifier expected. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,21): error TS2300: Duplicate identifier 'default'. +tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts(5,36): error TS2307: Cannot find module 'somemodule'. ==== tests/cases/compiler/es6ImportNamedImportIdentifiersParsing.ts (13 errors) ==== - import { yield } from "somemodule"; // Allowed ~~~~~ !!! error TS2300: Duplicate identifier 'yield'. diff --git a/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.js b/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.js index 8db7fcd6f9c57..5e22dd98bd442 100644 --- a/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.js +++ b/tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.js @@ -1,5 +1,4 @@ //// [es6ImportNamedImportIdentifiersParsing.ts] - import { yield } from "somemodule"; // Allowed import { default } from "somemodule"; // Error - as this is keyword that is not allowed as identifier import { yield as default } from "somemodule"; // error to use default as binding name diff --git a/tests/baselines/reference/es6ImportNamedImportInEs5.js b/tests/baselines/reference/es6ImportNamedImportInEs5.js index 9e025dca61be9..8cedfa664a807 100644 --- a/tests/baselines/reference/es6ImportNamedImportInEs5.js +++ b/tests/baselines/reference/es6ImportNamedImportInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportInEs5.ts] //// //// [es6ImportNamedImportInEs5_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportInEs5.symbols b/tests/baselines/reference/es6ImportNamedImportInEs5.symbols index f9e949e7efb8a..b08aff200fb6b 100644 --- a/tests/baselines/reference/es6ImportNamedImportInEs5.symbols +++ b/tests/baselines/reference/es6ImportNamedImportInEs5.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/es6ImportNamedImportInEs5_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 0, 10)) export var x = a; ->x : Symbol(x, Decl(es6ImportNamedImportInEs5_0.ts, 2, 10)) ->a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 1, 10)) +>x : Symbol(x, Decl(es6ImportNamedImportInEs5_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 0, 10)) export var m = a; ->m : Symbol(m, Decl(es6ImportNamedImportInEs5_0.ts, 3, 10)) ->a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 1, 10)) +>m : Symbol(m, Decl(es6ImportNamedImportInEs5_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportInEs5_0.ts, 0, 10)) export var a1 = 10; ->a1 : Symbol(a1, Decl(es6ImportNamedImportInEs5_0.ts, 4, 10)) +>a1 : Symbol(a1, Decl(es6ImportNamedImportInEs5_0.ts, 3, 10)) export var x1 = 10; ->x1 : Symbol(x1, Decl(es6ImportNamedImportInEs5_0.ts, 5, 10)) +>x1 : Symbol(x1, Decl(es6ImportNamedImportInEs5_0.ts, 4, 10)) export var z1 = 10; ->z1 : Symbol(z1, Decl(es6ImportNamedImportInEs5_0.ts, 6, 10)) +>z1 : Symbol(z1, Decl(es6ImportNamedImportInEs5_0.ts, 5, 10)) export var z2 = 10; ->z2 : Symbol(z2, Decl(es6ImportNamedImportInEs5_0.ts, 7, 10)) +>z2 : Symbol(z2, Decl(es6ImportNamedImportInEs5_0.ts, 6, 10)) export var aaaa = 10; ->aaaa : Symbol(aaaa, Decl(es6ImportNamedImportInEs5_0.ts, 8, 10)) +>aaaa : Symbol(aaaa, Decl(es6ImportNamedImportInEs5_0.ts, 7, 10)) === tests/cases/compiler/es6ImportNamedImportInEs5_1.ts === import { } from "./es6ImportNamedImportInEs5_0"; diff --git a/tests/baselines/reference/es6ImportNamedImportInEs5.types b/tests/baselines/reference/es6ImportNamedImportInEs5.types index f2af5280fc2e2..3a907acc11e51 100644 --- a/tests/baselines/reference/es6ImportNamedImportInEs5.types +++ b/tests/baselines/reference/es6ImportNamedImportInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImportInEs5_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js index d64b517c50f4c..54dc4ca750cb6 100644 --- a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js +++ b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportInExportAssignment.ts] //// //// [es6ImportNamedImportInExportAssignment_0.ts] - export var a = 10; //// [es6ImportNamedImportInExportAssignment_1.ts] diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols index 03ca0740f08a9..c9344acad9573 100644 --- a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols +++ b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportNamedImportInExportAssignment_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportNamedImportInExportAssignment_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportNamedImportInExportAssignment_0.ts, 0, 10)) === tests/cases/compiler/es6ImportNamedImportInExportAssignment_1.ts === import { a } from "./es6ImportNamedImportInExportAssignment_0"; diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types index 5b550c77a00c4..1d6027e4b5b97 100644 --- a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types +++ b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImportInExportAssignment_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.js b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.js index 38cda17bd7efe..3acd2f9c4a075 100644 --- a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.js +++ b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportInIndirectExportAssignment.ts] //// //// [es6ImportNamedImportInIndirectExportAssignment_0.ts] - export module a { export class c { } diff --git a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols index 77b93c3ef0022..257ea8c8c852a 100644 --- a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols +++ b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/es6ImportNamedImportInIndirectExportAssignment_0.ts === - export module a { >a : Symbol(a, Decl(es6ImportNamedImportInIndirectExportAssignment_0.ts, 0, 0)) export class c { ->c : Symbol(c, Decl(es6ImportNamedImportInIndirectExportAssignment_0.ts, 1, 17)) +>c : Symbol(c, Decl(es6ImportNamedImportInIndirectExportAssignment_0.ts, 0, 17)) } } diff --git a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.types b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.types index d4dd62aacb2bf..f875f79aca935 100644 --- a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.types +++ b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportNamedImportInIndirectExportAssignment_0.ts === - export module a { >a : typeof a diff --git a/tests/baselines/reference/es6ImportNamedImportMergeErrors.errors.txt b/tests/baselines/reference/es6ImportNamedImportMergeErrors.errors.txt index 0646e4f2fd65d..c607e2e1652ca 100644 --- a/tests/baselines/reference/es6ImportNamedImportMergeErrors.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportMergeErrors.errors.txt @@ -5,7 +5,6 @@ tests/cases/compiler/es6ImportNamedImportMergeErrors_1.ts(10,16): error TS2300: ==== tests/cases/compiler/es6ImportNamedImportMergeErrors_0.ts (0 errors) ==== - export var a = 10; export var x = a; export var z = a; diff --git a/tests/baselines/reference/es6ImportNamedImportMergeErrors.js b/tests/baselines/reference/es6ImportNamedImportMergeErrors.js index 261039bcc10bc..61b2cbf76b3e2 100644 --- a/tests/baselines/reference/es6ImportNamedImportMergeErrors.js +++ b/tests/baselines/reference/es6ImportNamedImportMergeErrors.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportMergeErrors.ts] //// //// [es6ImportNamedImportMergeErrors_0.ts] - export var a = 10; export var x = a; export var z = a; diff --git a/tests/baselines/reference/es6ImportNamedImportNoExportMember.errors.txt b/tests/baselines/reference/es6ImportNamedImportNoExportMember.errors.txt index 47a836fd42240..31c8002f73547 100644 --- a/tests/baselines/reference/es6ImportNamedImportNoExportMember.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportNoExportMember.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/es6ImportNamedImport_1.ts(2,10): error TS2305: Module '"tes ==== tests/cases/compiler/es6ImportNamedImportNoExportMember_0.ts (0 errors) ==== - export var a = 10; export var x = a; diff --git a/tests/baselines/reference/es6ImportNamedImportNoExportMember.js b/tests/baselines/reference/es6ImportNamedImportNoExportMember.js index 4e78df34b6d30..2c8e9fe5fecfd 100644 --- a/tests/baselines/reference/es6ImportNamedImportNoExportMember.js +++ b/tests/baselines/reference/es6ImportNamedImportNoExportMember.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportNoExportMember.ts] //// //// [es6ImportNamedImportNoExportMember_0.ts] - export var a = 10; export var x = a; diff --git a/tests/baselines/reference/es6ImportNamedImportNoNamedExports.errors.txt b/tests/baselines/reference/es6ImportNamedImportNoNamedExports.errors.txt index e2cacba59e8a2..66fa2d217c279 100644 --- a/tests/baselines/reference/es6ImportNamedImportNoNamedExports.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportNoNamedExports.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/es6ImportNamedImportNoNamedExports_1.ts(2,10): error TS2305 ==== tests/cases/compiler/es6ImportNamedImportNoNamedExports_0.ts (0 errors) ==== - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportNamedImportNoNamedExports.js b/tests/baselines/reference/es6ImportNamedImportNoNamedExports.js index a02116b314db6..ea0d398355ec8 100644 --- a/tests/baselines/reference/es6ImportNamedImportNoNamedExports.js +++ b/tests/baselines/reference/es6ImportNamedImportNoNamedExports.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportNoNamedExports.ts] //// //// [es6ImportNamedImportNoNamedExports_0.ts] - var a = 10; export = a; diff --git a/tests/baselines/reference/es6ImportNamedImportParsingError.errors.txt b/tests/baselines/reference/es6ImportNamedImportParsingError.errors.txt index 585cc51fb9252..aa89e2dc9977d 100644 --- a/tests/baselines/reference/es6ImportNamedImportParsingError.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportParsingError.errors.txt @@ -15,7 +15,6 @@ tests/cases/compiler/es6ImportNamedImportParsingError_1.ts(4,20): error TS1005: ==== tests/cases/compiler/es6ImportNamedImportParsingError_0.ts (0 errors) ==== - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportParsingError.js b/tests/baselines/reference/es6ImportNamedImportParsingError.js index 81f141b3dd858..76f14f91ff2b3 100644 --- a/tests/baselines/reference/es6ImportNamedImportParsingError.js +++ b/tests/baselines/reference/es6ImportNamedImportParsingError.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportParsingError.ts] //// //// [es6ImportNamedImportParsingError_0.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportWithExport.errors.txt b/tests/baselines/reference/es6ImportNamedImportWithExport.errors.txt index 3b2d6b0cbd0d7..61e0d2983494c 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportNamedImportWithExport.errors.txt @@ -23,7 +23,6 @@ tests/cases/compiler/client.ts(26,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportWithExport.js b/tests/baselines/reference/es6ImportNamedImportWithExport.js index 13e2d40144b26..b864f86258ef1 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithExport.js +++ b/tests/baselines/reference/es6ImportNamedImportWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportWithExport.ts] //// //// [server.ts] - export var a = 10; export var x = a; export var m = a; diff --git a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.js b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.js index 0aa3214e5d708..2a00feccd3b59 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.js +++ b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportNamedImportWithTypesAndValues.ts] //// //// [server.ts] - export interface I { prop: string; } diff --git a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.symbols b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.symbols index 5abd8c888672b..2343f1be1410f 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.symbols +++ b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/server.ts === - export interface I { >I : Symbol(I, Decl(server.ts, 0, 0)) prop: string; ->prop : Symbol(I.prop, Decl(server.ts, 1, 20)) +>prop : Symbol(I.prop, Decl(server.ts, 0, 20)) } export interface I2 { ->I2 : Symbol(I2, Decl(server.ts, 3, 1)) +>I2 : Symbol(I2, Decl(server.ts, 2, 1)) prop2: string; ->prop2 : Symbol(I2.prop2, Decl(server.ts, 4, 21)) +>prop2 : Symbol(I2.prop2, Decl(server.ts, 3, 21)) } export class C implements I { ->C : Symbol(C, Decl(server.ts, 6, 1)) +>C : Symbol(C, Decl(server.ts, 5, 1)) >I : Symbol(I, Decl(server.ts, 0, 0)) prop = "hello"; ->prop : Symbol(C.prop, Decl(server.ts, 7, 29)) +>prop : Symbol(C.prop, Decl(server.ts, 6, 29)) } export class C2 implements I2 { ->C2 : Symbol(C2, Decl(server.ts, 9, 1)) ->I2 : Symbol(I2, Decl(server.ts, 3, 1)) +>C2 : Symbol(C2, Decl(server.ts, 8, 1)) +>I2 : Symbol(I2, Decl(server.ts, 2, 1)) prop2 = "world"; ->prop2 : Symbol(C2.prop2, Decl(server.ts, 10, 31)) +>prop2 : Symbol(C2.prop2, Decl(server.ts, 9, 31)) } === tests/cases/compiler/client.ts === diff --git a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.types b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.types index 11c6caf3dbe8f..43e98cb1ad8a5 100644 --- a/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.types +++ b/tests/baselines/reference/es6ImportNamedImportWithTypesAndValues.types @@ -1,5 +1,4 @@ === tests/cases/compiler/server.ts === - export interface I { >I : I diff --git a/tests/baselines/reference/es6ImportParseErrors.errors.txt b/tests/baselines/reference/es6ImportParseErrors.errors.txt index d1e1cb7d00de8..671692cd121fa 100644 --- a/tests/baselines/reference/es6ImportParseErrors.errors.txt +++ b/tests/baselines/reference/es6ImportParseErrors.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/es6ImportParseErrors.ts(2,1): error TS1128: Declaration or statement expected. +tests/cases/compiler/es6ImportParseErrors.ts(1,1): error TS1128: Declaration or statement expected. ==== tests/cases/compiler/es6ImportParseErrors.ts (1 errors) ==== - import 10; ~~~~~~ !!! error TS1128: Declaration or statement expected. \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportParseErrors.js b/tests/baselines/reference/es6ImportParseErrors.js index a42d65fbc9dcc..faa7bc161ce0f 100644 --- a/tests/baselines/reference/es6ImportParseErrors.js +++ b/tests/baselines/reference/es6ImportParseErrors.js @@ -1,5 +1,4 @@ //// [es6ImportParseErrors.ts] - import 10; //// [es6ImportParseErrors.js] diff --git a/tests/baselines/reference/es6ImportWithoutFromClause.js b/tests/baselines/reference/es6ImportWithoutFromClause.js index cc8509baadeb6..f23ac0381c7d1 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClause.js +++ b/tests/baselines/reference/es6ImportWithoutFromClause.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClause.ts] //// //// [es6ImportWithoutFromClause_0.ts] - export var a = 10; //// [es6ImportWithoutFromClause_1.ts] diff --git a/tests/baselines/reference/es6ImportWithoutFromClause.symbols b/tests/baselines/reference/es6ImportWithoutFromClause.symbols index 31eafdf655c5f..4298fc777247d 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClause.symbols +++ b/tests/baselines/reference/es6ImportWithoutFromClause.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportWithoutFromClause_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportWithoutFromClause_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportWithoutFromClause_0.ts, 0, 10)) === tests/cases/compiler/es6ImportWithoutFromClause_1.ts === import "es6ImportWithoutFromClause_0"; diff --git a/tests/baselines/reference/es6ImportWithoutFromClause.types b/tests/baselines/reference/es6ImportWithoutFromClause.types index cd49acbcd0f70..bf017cb2fc051 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClause.types +++ b/tests/baselines/reference/es6ImportWithoutFromClause.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClause_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.js b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.js index d83ba9370eecb..f6134e3d89956 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.js +++ b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClauseAmd.ts] //// //// [es6ImportWithoutFromClauseAmd_0.ts] - export var a = 10; //// [es6ImportWithoutFromClauseAmd_1.ts] diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.symbols b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.symbols index 36e1e79f0b579..3e92e2f00d16f 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.symbols +++ b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportWithoutFromClauseAmd_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportWithoutFromClauseAmd_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportWithoutFromClauseAmd_0.ts, 0, 10)) === tests/cases/compiler/es6ImportWithoutFromClauseAmd_1.ts === export var b = 10; diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.types b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.types index 5099dee908b78..0638e4e5e6993 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseAmd.types +++ b/tests/baselines/reference/es6ImportWithoutFromClauseAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClauseAmd_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.js b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.js index b11e2ea9a07e2..d0a96043465c0 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.js +++ b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClauseInEs5.ts] //// //// [es6ImportWithoutFromClauseInEs5_0.ts] - export var a = 10; //// [es6ImportWithoutFromClauseInEs5_1.ts] diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.symbols b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.symbols index c8db6eff479d4..b1701aa72081c 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.symbols +++ b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/es6ImportWithoutFromClauseInEs5_0.ts === - export var a = 10; ->a : Symbol(a, Decl(es6ImportWithoutFromClauseInEs5_0.ts, 1, 10)) +>a : Symbol(a, Decl(es6ImportWithoutFromClauseInEs5_0.ts, 0, 10)) === tests/cases/compiler/es6ImportWithoutFromClauseInEs5_1.ts === import "es6ImportWithoutFromClauseInEs5_0"; diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.types b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.types index 1e90de3223f66..02eacf11b25f7 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.types +++ b/tests/baselines/reference/es6ImportWithoutFromClauseInEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClauseInEs5_0.ts === - export var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.js b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.js index 51bb0f3338d70..8fa9de0a98dd4 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.js +++ b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClauseNonInstantiatedModule.ts] //// //// [es6ImportWithoutFromClauseNonInstantiatedModule_0.ts] - export interface i { } diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.symbols b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.symbols index 0fe8e68e1a3c4..e520bede4d8a6 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.symbols +++ b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClauseNonInstantiatedModule_0.ts === - export interface i { >i : Symbol(i, Decl(es6ImportWithoutFromClauseNonInstantiatedModule_0.ts, 0, 0)) } diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.types b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.types index 2be3f67f1e963..62eff2856a394 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.types +++ b/tests/baselines/reference/es6ImportWithoutFromClauseNonInstantiatedModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ImportWithoutFromClauseNonInstantiatedModule_0.ts === - export interface i { >i : i } diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.errors.txt b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.errors.txt index da865698e56a8..cda3f545070bd 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.errors.txt +++ b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/client.ts(1,1): error TS1191: An import declaration cannot ==== tests/cases/compiler/server.ts (0 errors) ==== - export var a = 10; ==== tests/cases/compiler/client.ts (1 errors) ==== diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js index 99214d2a2c6c8..755ec99d2584c 100644 --- a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js +++ b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6ImportWithoutFromClauseWithExport.ts] //// //// [server.ts] - export var a = 10; //// [client.ts] diff --git a/tests/baselines/reference/es6MemberScoping.errors.txt b/tests/baselines/reference/es6MemberScoping.errors.txt index 07788a6864822..db5c5b3edf023 100644 --- a/tests/baselines/reference/es6MemberScoping.errors.txt +++ b/tests/baselines/reference/es6MemberScoping.errors.txt @@ -1,9 +1,7 @@ -tests/cases/compiler/es6MemberScoping.ts(9,21): error TS2304: Cannot find name 'store'. +tests/cases/compiler/es6MemberScoping.ts(7,21): error TS2304: Cannot find name 'store'. ==== tests/cases/compiler/es6MemberScoping.ts (1 errors) ==== - - class Foo { constructor(store: string) { } diff --git a/tests/baselines/reference/es6MemberScoping.js b/tests/baselines/reference/es6MemberScoping.js index d38a64c611a03..de442616dc3ae 100644 --- a/tests/baselines/reference/es6MemberScoping.js +++ b/tests/baselines/reference/es6MemberScoping.js @@ -1,6 +1,4 @@ //// [es6MemberScoping.ts] - - class Foo { constructor(store: string) { } diff --git a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.js b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.js index 3e4475f2ffa2c..6c2266f10ff2a 100644 --- a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.js +++ b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.js @@ -1,5 +1,4 @@ //// [es6ModuleConstEnumDeclaration2.ts] - export const enum e1 { a, b, diff --git a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.symbols b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.symbols index 2e756cf287546..37130cfd124fd 100644 --- a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.symbols +++ b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.symbols @@ -1,148 +1,147 @@ === tests/cases/compiler/es6ModuleConstEnumDeclaration2.ts === - export const enum e1 { >e1 : Symbol(e1, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 0)) a, ->a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) b, ->b : Symbol(e1.b, Decl(es6ModuleConstEnumDeclaration2.ts, 2, 6)) +>b : Symbol(e1.b, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 6)) c ->c : Symbol(e1.c, Decl(es6ModuleConstEnumDeclaration2.ts, 3, 6)) +>c : Symbol(e1.c, Decl(es6ModuleConstEnumDeclaration2.ts, 2, 6)) } const enum e2 { ->e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 1)) +>e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 4, 1)) x, ->x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) +>x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) y, ->y : Symbol(e2.y, Decl(es6ModuleConstEnumDeclaration2.ts, 7, 6)) +>y : Symbol(e2.y, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 6)) z ->z : Symbol(e2.z, Decl(es6ModuleConstEnumDeclaration2.ts, 8, 6)) +>z : Symbol(e2.z, Decl(es6ModuleConstEnumDeclaration2.ts, 7, 6)) } var x = e1.a; ->x : Symbol(x, Decl(es6ModuleConstEnumDeclaration2.ts, 11, 3)) ->e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>x : Symbol(x, Decl(es6ModuleConstEnumDeclaration2.ts, 10, 3)) +>e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) >e1 : Symbol(e1, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 0)) ->a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) var y = e2.x; ->y : Symbol(y, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 3)) ->e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) ->e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 1)) ->x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) +>y : Symbol(y, Decl(es6ModuleConstEnumDeclaration2.ts, 11, 3)) +>e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) +>e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 4, 1)) +>x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) export module m1 { ->m1 : Symbol(m1, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 13)) +>m1 : Symbol(m1, Decl(es6ModuleConstEnumDeclaration2.ts, 11, 13)) export const enum e3 { ->e3 : Symbol(e3, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 18)) +>e3 : Symbol(e3, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 18)) a, ->a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) +>a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) b, ->b : Symbol(e3.b, Decl(es6ModuleConstEnumDeclaration2.ts, 15, 10)) +>b : Symbol(e3.b, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 10)) c ->c : Symbol(e3.c, Decl(es6ModuleConstEnumDeclaration2.ts, 16, 10)) +>c : Symbol(e3.c, Decl(es6ModuleConstEnumDeclaration2.ts, 15, 10)) } const enum e4 { ->e4 : Symbol(e4, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 5)) +>e4 : Symbol(e4, Decl(es6ModuleConstEnumDeclaration2.ts, 17, 5)) x, ->x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 19, 19)) +>x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 19)) y, ->y : Symbol(e4.y, Decl(es6ModuleConstEnumDeclaration2.ts, 20, 10)) +>y : Symbol(e4.y, Decl(es6ModuleConstEnumDeclaration2.ts, 19, 10)) z ->z : Symbol(e4.z, Decl(es6ModuleConstEnumDeclaration2.ts, 21, 10)) +>z : Symbol(e4.z, Decl(es6ModuleConstEnumDeclaration2.ts, 20, 10)) } var x1 = e1.a; ->x1 : Symbol(x1, Decl(es6ModuleConstEnumDeclaration2.ts, 24, 7)) ->e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>x1 : Symbol(x1, Decl(es6ModuleConstEnumDeclaration2.ts, 23, 7)) +>e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) >e1 : Symbol(e1, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 0)) ->a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) var y1 = e2.x; ->y1 : Symbol(y1, Decl(es6ModuleConstEnumDeclaration2.ts, 25, 7)) ->e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) ->e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 1)) ->x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) +>y1 : Symbol(y1, Decl(es6ModuleConstEnumDeclaration2.ts, 24, 7)) +>e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) +>e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 4, 1)) +>x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) var x2 = e3.a; ->x2 : Symbol(x2, Decl(es6ModuleConstEnumDeclaration2.ts, 26, 7)) ->e3.a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) ->e3 : Symbol(e3, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 18)) ->a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) +>x2 : Symbol(x2, Decl(es6ModuleConstEnumDeclaration2.ts, 25, 7)) +>e3.a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) +>e3 : Symbol(e3, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 18)) +>a : Symbol(e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) var y2 = e4.x; ->y2 : Symbol(y2, Decl(es6ModuleConstEnumDeclaration2.ts, 27, 7)) ->e4.x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 19, 19)) ->e4 : Symbol(e4, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 5)) ->x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 19, 19)) +>y2 : Symbol(y2, Decl(es6ModuleConstEnumDeclaration2.ts, 26, 7)) +>e4.x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 19)) +>e4 : Symbol(e4, Decl(es6ModuleConstEnumDeclaration2.ts, 17, 5)) +>x : Symbol(e4.x, Decl(es6ModuleConstEnumDeclaration2.ts, 18, 19)) } module m2 { ->m2 : Symbol(m2, Decl(es6ModuleConstEnumDeclaration2.ts, 28, 1)) +>m2 : Symbol(m2, Decl(es6ModuleConstEnumDeclaration2.ts, 27, 1)) export const enum e5 { ->e5 : Symbol(e5, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 11)) +>e5 : Symbol(e5, Decl(es6ModuleConstEnumDeclaration2.ts, 28, 11)) a, ->a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 30, 26)) +>a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 26)) b, ->b : Symbol(e5.b, Decl(es6ModuleConstEnumDeclaration2.ts, 31, 10)) +>b : Symbol(e5.b, Decl(es6ModuleConstEnumDeclaration2.ts, 30, 10)) c ->c : Symbol(e5.c, Decl(es6ModuleConstEnumDeclaration2.ts, 32, 10)) +>c : Symbol(e5.c, Decl(es6ModuleConstEnumDeclaration2.ts, 31, 10)) } const enum e6 { ->e6 : Symbol(e6, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 5)) +>e6 : Symbol(e6, Decl(es6ModuleConstEnumDeclaration2.ts, 33, 5)) x, ->x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 35, 19)) +>x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 19)) y, ->y : Symbol(e6.y, Decl(es6ModuleConstEnumDeclaration2.ts, 36, 10)) +>y : Symbol(e6.y, Decl(es6ModuleConstEnumDeclaration2.ts, 35, 10)) z ->z : Symbol(e6.z, Decl(es6ModuleConstEnumDeclaration2.ts, 37, 10)) +>z : Symbol(e6.z, Decl(es6ModuleConstEnumDeclaration2.ts, 36, 10)) } var x1 = e1.a; ->x1 : Symbol(x1, Decl(es6ModuleConstEnumDeclaration2.ts, 40, 7)) ->e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>x1 : Symbol(x1, Decl(es6ModuleConstEnumDeclaration2.ts, 39, 7)) +>e1.a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) >e1 : Symbol(e1, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 0)) ->a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 1, 22)) +>a : Symbol(e1.a, Decl(es6ModuleConstEnumDeclaration2.ts, 0, 22)) var y1 = e2.x; ->y1 : Symbol(y1, Decl(es6ModuleConstEnumDeclaration2.ts, 41, 7)) ->e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) ->e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 1)) ->x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 6, 15)) +>y1 : Symbol(y1, Decl(es6ModuleConstEnumDeclaration2.ts, 40, 7)) +>e2.x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) +>e2 : Symbol(e2, Decl(es6ModuleConstEnumDeclaration2.ts, 4, 1)) +>x : Symbol(e2.x, Decl(es6ModuleConstEnumDeclaration2.ts, 5, 15)) var x2 = e5.a; ->x2 : Symbol(x2, Decl(es6ModuleConstEnumDeclaration2.ts, 42, 7)) ->e5.a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 30, 26)) ->e5 : Symbol(e5, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 11)) ->a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 30, 26)) +>x2 : Symbol(x2, Decl(es6ModuleConstEnumDeclaration2.ts, 41, 7)) +>e5.a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 26)) +>e5 : Symbol(e5, Decl(es6ModuleConstEnumDeclaration2.ts, 28, 11)) +>a : Symbol(e5.a, Decl(es6ModuleConstEnumDeclaration2.ts, 29, 26)) var y2 = e6.x; ->y2 : Symbol(y2, Decl(es6ModuleConstEnumDeclaration2.ts, 43, 7)) ->e6.x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 35, 19)) ->e6 : Symbol(e6, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 5)) ->x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 35, 19)) +>y2 : Symbol(y2, Decl(es6ModuleConstEnumDeclaration2.ts, 42, 7)) +>e6.x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 19)) +>e6 : Symbol(e6, Decl(es6ModuleConstEnumDeclaration2.ts, 33, 5)) +>x : Symbol(e6.x, Decl(es6ModuleConstEnumDeclaration2.ts, 34, 19)) var x3 = m1.e3.a; ->x3 : Symbol(x3, Decl(es6ModuleConstEnumDeclaration2.ts, 44, 7)) ->m1.e3.a : Symbol(m1.e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) ->m1.e3 : Symbol(m1.e3, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 18)) ->m1 : Symbol(m1, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 13)) ->e3 : Symbol(m1.e3, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 18)) ->a : Symbol(m1.e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 14, 26)) +>x3 : Symbol(x3, Decl(es6ModuleConstEnumDeclaration2.ts, 43, 7)) +>m1.e3.a : Symbol(m1.e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) +>m1.e3 : Symbol(m1.e3, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 18)) +>m1 : Symbol(m1, Decl(es6ModuleConstEnumDeclaration2.ts, 11, 13)) +>e3 : Symbol(m1.e3, Decl(es6ModuleConstEnumDeclaration2.ts, 12, 18)) +>a : Symbol(m1.e3.a, Decl(es6ModuleConstEnumDeclaration2.ts, 13, 26)) } diff --git a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.types b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.types index ee0cb195a1aed..b31fdc63305c3 100644 --- a/tests/baselines/reference/es6ModuleConstEnumDeclaration2.types +++ b/tests/baselines/reference/es6ModuleConstEnumDeclaration2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6ModuleConstEnumDeclaration2.ts === - export const enum e1 { >e1 : e1 diff --git a/tests/baselines/reference/es6ModuleInternalNamedImports.errors.txt b/tests/baselines/reference/es6ModuleInternalNamedImports.errors.txt index fb49f08e2e0de..054c431c65dd0 100644 --- a/tests/baselines/reference/es6ModuleInternalNamedImports.errors.txt +++ b/tests/baselines/reference/es6ModuleInternalNamedImports.errors.txt @@ -1,3 +1,4 @@ +tests/cases/compiler/es6ModuleInternalNamedImports.ts(22,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(23,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(24,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(25,5): error TS1194: Export declarations are not permitted in a namespace. @@ -5,11 +6,9 @@ tests/cases/compiler/es6ModuleInternalNamedImports.ts(26,5): error TS1194: Expor tests/cases/compiler/es6ModuleInternalNamedImports.ts(27,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(28,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports.ts(29,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/es6ModuleInternalNamedImports.ts(30,5): error TS1194: Export declarations are not permitted in a namespace. ==== tests/cases/compiler/es6ModuleInternalNamedImports.ts (8 errors) ==== - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es6ModuleInternalNamedImports.js b/tests/baselines/reference/es6ModuleInternalNamedImports.js index fe2e0217795c2..b9fa0de2a3227 100644 --- a/tests/baselines/reference/es6ModuleInternalNamedImports.js +++ b/tests/baselines/reference/es6ModuleInternalNamedImports.js @@ -1,5 +1,4 @@ //// [es6ModuleInternalNamedImports.ts] - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es6ModuleInternalNamedImports2.errors.txt b/tests/baselines/reference/es6ModuleInternalNamedImports2.errors.txt index af8de2d7fe222..65c326ddb274a 100644 --- a/tests/baselines/reference/es6ModuleInternalNamedImports2.errors.txt +++ b/tests/baselines/reference/es6ModuleInternalNamedImports2.errors.txt @@ -1,3 +1,4 @@ +tests/cases/compiler/es6ModuleInternalNamedImports2.ts(24,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(25,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(26,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(27,5): error TS1194: Export declarations are not permitted in a namespace. @@ -5,11 +6,9 @@ tests/cases/compiler/es6ModuleInternalNamedImports2.ts(28,5): error TS1194: Expo tests/cases/compiler/es6ModuleInternalNamedImports2.ts(29,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(30,5): error TS1194: Export declarations are not permitted in a namespace. tests/cases/compiler/es6ModuleInternalNamedImports2.ts(31,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/es6ModuleInternalNamedImports2.ts(32,5): error TS1194: Export declarations are not permitted in a namespace. ==== tests/cases/compiler/es6ModuleInternalNamedImports2.ts (8 errors) ==== - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es6ModuleInternalNamedImports2.js b/tests/baselines/reference/es6ModuleInternalNamedImports2.js index 93d8f40c1d272..f5546d47d3498 100644 --- a/tests/baselines/reference/es6ModuleInternalNamedImports2.js +++ b/tests/baselines/reference/es6ModuleInternalNamedImports2.js @@ -1,5 +1,4 @@ //// [es6ModuleInternalNamedImports2.ts] - export module M { // variable export var M_V = 0; diff --git a/tests/baselines/reference/es6UseOfTopLevelRequire.js b/tests/baselines/reference/es6UseOfTopLevelRequire.js index fa7295df989d8..ee65d1b7e70b5 100644 --- a/tests/baselines/reference/es6UseOfTopLevelRequire.js +++ b/tests/baselines/reference/es6UseOfTopLevelRequire.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/es6UseOfTopLevelRequire.ts] //// //// [b.ts] - export default function require(s: string): void { } diff --git a/tests/baselines/reference/es6UseOfTopLevelRequire.symbols b/tests/baselines/reference/es6UseOfTopLevelRequire.symbols index 710bd675210ce..de8cdbed9c3bb 100644 --- a/tests/baselines/reference/es6UseOfTopLevelRequire.symbols +++ b/tests/baselines/reference/es6UseOfTopLevelRequire.symbols @@ -13,10 +13,9 @@ var x = exports + 2; >exports : Symbol(exports, Decl(a.ts, 3, 6)) === tests/cases/compiler/b.ts === - export default function require(s: string): void { >require : Symbol(require, Decl(b.ts, 0, 0)) ->s : Symbol(s, Decl(b.ts, 1, 32)) +>s : Symbol(s, Decl(b.ts, 0, 32)) } === tests/cases/compiler/c.ts === diff --git a/tests/baselines/reference/es6UseOfTopLevelRequire.types b/tests/baselines/reference/es6UseOfTopLevelRequire.types index 06acc9c2b424b..11462c850b248 100644 --- a/tests/baselines/reference/es6UseOfTopLevelRequire.types +++ b/tests/baselines/reference/es6UseOfTopLevelRequire.types @@ -17,7 +17,6 @@ var x = exports + 2; >2 : 2 === tests/cases/compiler/b.ts === - export default function require(s: string): void { >require : (s: string) => void >s : string diff --git a/tests/baselines/reference/es6modulekind.js b/tests/baselines/reference/es6modulekind.js index 96b315389d10e..06872fe7d9fad 100644 --- a/tests/baselines/reference/es6modulekind.js +++ b/tests/baselines/reference/es6modulekind.js @@ -1,5 +1,4 @@ //// [es6modulekind.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es6modulekind.symbols b/tests/baselines/reference/es6modulekind.symbols index 877199729e643..cc563db6826ac 100644 --- a/tests/baselines/reference/es6modulekind.symbols +++ b/tests/baselines/reference/es6modulekind.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekind.ts === - export default class A >A : Symbol(A, Decl(es6modulekind.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es6modulekind.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6modulekind.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6modulekind.types b/tests/baselines/reference/es6modulekind.types index 8994eb6657a4f..a8b6fa077f01b 100644 --- a/tests/baselines/reference/es6modulekind.types +++ b/tests/baselines/reference/es6modulekind.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekind.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es6modulekindWithES2015Target.js b/tests/baselines/reference/es6modulekindWithES2015Target.js index 98808fd1c6550..c0762b88eff68 100644 --- a/tests/baselines/reference/es6modulekindWithES2015Target.js +++ b/tests/baselines/reference/es6modulekindWithES2015Target.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES2015Target.ts] - export default class A { constructor () diff --git a/tests/baselines/reference/es6modulekindWithES2015Target.symbols b/tests/baselines/reference/es6modulekindWithES2015Target.symbols index 2b6f8a03aa7f0..b7cf2e19c744e 100644 --- a/tests/baselines/reference/es6modulekindWithES2015Target.symbols +++ b/tests/baselines/reference/es6modulekindWithES2015Target.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES2015Target.ts === - export default class A >A : Symbol(A, Decl(es6modulekindWithES2015Target.ts, 0, 0)) { @@ -9,7 +8,7 @@ export default class A } public B() ->B : Symbol(A.B, Decl(es6modulekindWithES2015Target.ts, 6, 5)) +>B : Symbol(A.B, Decl(es6modulekindWithES2015Target.ts, 5, 5)) { return 42; } diff --git a/tests/baselines/reference/es6modulekindWithES2015Target.types b/tests/baselines/reference/es6modulekindWithES2015Target.types index 313fb612d8e51..018d06e074592 100644 --- a/tests/baselines/reference/es6modulekindWithES2015Target.types +++ b/tests/baselines/reference/es6modulekindWithES2015Target.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES2015Target.ts === - export default class A >A : A { diff --git a/tests/baselines/reference/es6modulekindWithES5Target.js b/tests/baselines/reference/es6modulekindWithES5Target.js index 66967cbc89fc9..8778d17878631 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target.js +++ b/tests/baselines/reference/es6modulekindWithES5Target.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target.ts] - export class C { static s = 0; p = 1; diff --git a/tests/baselines/reference/es6modulekindWithES5Target.symbols b/tests/baselines/reference/es6modulekindWithES5Target.symbols index 2d2a3f6732cce..edba44a22230d 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target.symbols @@ -1,47 +1,46 @@ === tests/cases/compiler/es6modulekindWithES5Target.ts === - export class C { >C : Symbol(C, Decl(es6modulekindWithES5Target.ts, 0, 0)) static s = 0; ->s : Symbol(C.s, Decl(es6modulekindWithES5Target.ts, 1, 16)) +>s : Symbol(C.s, Decl(es6modulekindWithES5Target.ts, 0, 16)) p = 1; ->p : Symbol(C.p, Decl(es6modulekindWithES5Target.ts, 2, 17)) +>p : Symbol(C.p, Decl(es6modulekindWithES5Target.ts, 1, 17)) method() { } ->method : Symbol(C.method, Decl(es6modulekindWithES5Target.ts, 3, 10)) +>method : Symbol(C.method, Decl(es6modulekindWithES5Target.ts, 2, 10)) } export { C as C2 }; ->C : Symbol(C2, Decl(es6modulekindWithES5Target.ts, 6, 8)) ->C2 : Symbol(C2, Decl(es6modulekindWithES5Target.ts, 6, 8)) +>C : Symbol(C2, Decl(es6modulekindWithES5Target.ts, 5, 8)) +>C2 : Symbol(C2, Decl(es6modulekindWithES5Target.ts, 5, 8)) declare function foo(...args: any[]): any; ->foo : Symbol(foo, Decl(es6modulekindWithES5Target.ts, 6, 19)) ->args : Symbol(args, Decl(es6modulekindWithES5Target.ts, 8, 21)) +>foo : Symbol(foo, Decl(es6modulekindWithES5Target.ts, 5, 19)) +>args : Symbol(args, Decl(es6modulekindWithES5Target.ts, 7, 21)) @foo ->foo : Symbol(foo, Decl(es6modulekindWithES5Target.ts, 6, 19)) +>foo : Symbol(foo, Decl(es6modulekindWithES5Target.ts, 5, 19)) export class D { ->D : Symbol(D, Decl(es6modulekindWithES5Target.ts, 8, 42)) +>D : Symbol(D, Decl(es6modulekindWithES5Target.ts, 7, 42)) static s = 0; ->s : Symbol(D.s, Decl(es6modulekindWithES5Target.ts, 10, 16)) +>s : Symbol(D.s, Decl(es6modulekindWithES5Target.ts, 9, 16)) p = 1; ->p : Symbol(D.p, Decl(es6modulekindWithES5Target.ts, 11, 17)) +>p : Symbol(D.p, Decl(es6modulekindWithES5Target.ts, 10, 17)) method() { } ->method : Symbol(D.method, Decl(es6modulekindWithES5Target.ts, 12, 10)) +>method : Symbol(D.method, Decl(es6modulekindWithES5Target.ts, 11, 10)) } export { D as D2 }; ->D : Symbol(D2, Decl(es6modulekindWithES5Target.ts, 15, 8)) ->D2 : Symbol(D2, Decl(es6modulekindWithES5Target.ts, 15, 8)) +>D : Symbol(D2, Decl(es6modulekindWithES5Target.ts, 14, 8)) +>D2 : Symbol(D2, Decl(es6modulekindWithES5Target.ts, 14, 8)) class E { } ->E : Symbol(E, Decl(es6modulekindWithES5Target.ts, 15, 19)) +>E : Symbol(E, Decl(es6modulekindWithES5Target.ts, 14, 19)) export {E}; ->E : Symbol(E, Decl(es6modulekindWithES5Target.ts, 18, 8)) +>E : Symbol(E, Decl(es6modulekindWithES5Target.ts, 17, 8)) diff --git a/tests/baselines/reference/es6modulekindWithES5Target.types b/tests/baselines/reference/es6modulekindWithES5Target.types index 4b620fb9e17b0..018114be43dbd 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target.types +++ b/tests/baselines/reference/es6modulekindWithES5Target.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target.ts === - export class C { >C : C diff --git a/tests/baselines/reference/es6modulekindWithES5Target10.errors.txt b/tests/baselines/reference/es6modulekindWithES5Target10.errors.txt index fd01dafc11f44..16dfab2579484 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target10.errors.txt +++ b/tests/baselines/reference/es6modulekindWithES5Target10.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/es6modulekindWithES5Target10.ts(2,1): error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. -tests/cases/compiler/es6modulekindWithES5Target10.ts(2,20): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target10.ts(7,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/es6modulekindWithES5Target10.ts(1,1): error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. +tests/cases/compiler/es6modulekindWithES5Target10.ts(1,20): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target10.ts(6,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/es6modulekindWithES5Target10.ts (3 errors) ==== - import i = require("mod"); // Error; ~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS1202: Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead. diff --git a/tests/baselines/reference/es6modulekindWithES5Target10.js b/tests/baselines/reference/es6modulekindWithES5Target10.js index b8a66241780ef..037ff12a0b086 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target10.js +++ b/tests/baselines/reference/es6modulekindWithES5Target10.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target10.ts] - import i = require("mod"); // Error; diff --git a/tests/baselines/reference/es6modulekindWithES5Target11.js b/tests/baselines/reference/es6modulekindWithES5Target11.js index 4ec0802a5f5c3..ed3d44cb5380a 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target11.js +++ b/tests/baselines/reference/es6modulekindWithES5Target11.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target11.ts] - declare function foo(...args: any[]): any; @foo export default class C { diff --git a/tests/baselines/reference/es6modulekindWithES5Target11.symbols b/tests/baselines/reference/es6modulekindWithES5Target11.symbols index 144d306c5fb9e..39c351a0e5ec9 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target11.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target11.symbols @@ -1,27 +1,26 @@ === tests/cases/compiler/es6modulekindWithES5Target11.ts === - declare function foo(...args: any[]): any; >foo : Symbol(foo, Decl(es6modulekindWithES5Target11.ts, 0, 0)) ->args : Symbol(args, Decl(es6modulekindWithES5Target11.ts, 1, 21)) +>args : Symbol(args, Decl(es6modulekindWithES5Target11.ts, 0, 21)) @foo >foo : Symbol(foo, Decl(es6modulekindWithES5Target11.ts, 0, 0)) export default class C { ->C : Symbol(C, Decl(es6modulekindWithES5Target11.ts, 1, 42)) +>C : Symbol(C, Decl(es6modulekindWithES5Target11.ts, 0, 42)) static x() { return C.y; } ->x : Symbol(C.x, Decl(es6modulekindWithES5Target11.ts, 3, 24)) ->C.y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 4, 30)) ->C : Symbol(C, Decl(es6modulekindWithES5Target11.ts, 1, 42)) ->y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 4, 30)) +>x : Symbol(C.x, Decl(es6modulekindWithES5Target11.ts, 2, 24)) +>C.y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 3, 30)) +>C : Symbol(C, Decl(es6modulekindWithES5Target11.ts, 0, 42)) +>y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 3, 30)) static y = 1 ->y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 4, 30)) +>y : Symbol(C.y, Decl(es6modulekindWithES5Target11.ts, 3, 30)) p = 1; ->p : Symbol(C.p, Decl(es6modulekindWithES5Target11.ts, 5, 16)) +>p : Symbol(C.p, Decl(es6modulekindWithES5Target11.ts, 4, 16)) method() { } ->method : Symbol(C.method, Decl(es6modulekindWithES5Target11.ts, 6, 10)) +>method : Symbol(C.method, Decl(es6modulekindWithES5Target11.ts, 5, 10)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target11.types b/tests/baselines/reference/es6modulekindWithES5Target11.types index e3d922c044334..497d8e0af7808 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target11.types +++ b/tests/baselines/reference/es6modulekindWithES5Target11.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target11.ts === - declare function foo(...args: any[]): any; >foo : (...args: any[]) => any >args : any[] diff --git a/tests/baselines/reference/es6modulekindWithES5Target12.js b/tests/baselines/reference/es6modulekindWithES5Target12.js index 74646f73e556a..f0ccbf0701eca 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target12.js +++ b/tests/baselines/reference/es6modulekindWithES5Target12.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target12.ts] - export class C { } diff --git a/tests/baselines/reference/es6modulekindWithES5Target12.symbols b/tests/baselines/reference/es6modulekindWithES5Target12.symbols index e6469a6300a4b..a16baab08cead 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target12.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target12.symbols @@ -1,62 +1,61 @@ === tests/cases/compiler/es6modulekindWithES5Target12.ts === - export class C { ->C : Symbol(C, Decl(es6modulekindWithES5Target12.ts, 0, 0), Decl(es6modulekindWithES5Target12.ts, 2, 1)) +>C : Symbol(C, Decl(es6modulekindWithES5Target12.ts, 0, 0), Decl(es6modulekindWithES5Target12.ts, 1, 1)) } export namespace C { ->C : Symbol(C, Decl(es6modulekindWithES5Target12.ts, 0, 0), Decl(es6modulekindWithES5Target12.ts, 2, 1)) +>C : Symbol(C, Decl(es6modulekindWithES5Target12.ts, 0, 0), Decl(es6modulekindWithES5Target12.ts, 1, 1)) export const x = 1; ->x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 5, 16)) +>x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 4, 16)) } export enum E { ->E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 6, 1), Decl(es6modulekindWithES5Target12.ts, 10, 1), Decl(es6modulekindWithES5Target12.ts, 14, 1), Decl(es6modulekindWithES5Target12.ts, 18, 1)) +>E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 5, 1), Decl(es6modulekindWithES5Target12.ts, 9, 1), Decl(es6modulekindWithES5Target12.ts, 13, 1), Decl(es6modulekindWithES5Target12.ts, 17, 1)) w = 1 ->w : Symbol(E.w, Decl(es6modulekindWithES5Target12.ts, 8, 15)) +>w : Symbol(E.w, Decl(es6modulekindWithES5Target12.ts, 7, 15)) } export enum E { ->E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 6, 1), Decl(es6modulekindWithES5Target12.ts, 10, 1), Decl(es6modulekindWithES5Target12.ts, 14, 1), Decl(es6modulekindWithES5Target12.ts, 18, 1)) +>E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 5, 1), Decl(es6modulekindWithES5Target12.ts, 9, 1), Decl(es6modulekindWithES5Target12.ts, 13, 1), Decl(es6modulekindWithES5Target12.ts, 17, 1)) x = 2 ->x : Symbol(E.x, Decl(es6modulekindWithES5Target12.ts, 12, 15)) +>x : Symbol(E.x, Decl(es6modulekindWithES5Target12.ts, 11, 15)) } export namespace E { ->E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 6, 1), Decl(es6modulekindWithES5Target12.ts, 10, 1), Decl(es6modulekindWithES5Target12.ts, 14, 1), Decl(es6modulekindWithES5Target12.ts, 18, 1)) +>E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 5, 1), Decl(es6modulekindWithES5Target12.ts, 9, 1), Decl(es6modulekindWithES5Target12.ts, 13, 1), Decl(es6modulekindWithES5Target12.ts, 17, 1)) export const y = 1; ->y : Symbol(y, Decl(es6modulekindWithES5Target12.ts, 17, 16)) +>y : Symbol(y, Decl(es6modulekindWithES5Target12.ts, 16, 16)) } export namespace E { ->E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 6, 1), Decl(es6modulekindWithES5Target12.ts, 10, 1), Decl(es6modulekindWithES5Target12.ts, 14, 1), Decl(es6modulekindWithES5Target12.ts, 18, 1)) +>E : Symbol(E, Decl(es6modulekindWithES5Target12.ts, 5, 1), Decl(es6modulekindWithES5Target12.ts, 9, 1), Decl(es6modulekindWithES5Target12.ts, 13, 1), Decl(es6modulekindWithES5Target12.ts, 17, 1)) export const z = 1; ->z : Symbol(z, Decl(es6modulekindWithES5Target12.ts, 21, 16)) +>z : Symbol(z, Decl(es6modulekindWithES5Target12.ts, 20, 16)) } export namespace N { ->N : Symbol(N, Decl(es6modulekindWithES5Target12.ts, 22, 1), Decl(es6modulekindWithES5Target12.ts, 25, 1)) +>N : Symbol(N, Decl(es6modulekindWithES5Target12.ts, 21, 1), Decl(es6modulekindWithES5Target12.ts, 24, 1)) } export namespace N { ->N : Symbol(N, Decl(es6modulekindWithES5Target12.ts, 22, 1), Decl(es6modulekindWithES5Target12.ts, 25, 1)) +>N : Symbol(N, Decl(es6modulekindWithES5Target12.ts, 21, 1), Decl(es6modulekindWithES5Target12.ts, 24, 1)) export const x = 1; ->x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 28, 16)) +>x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 27, 16)) } export function F() { ->F : Symbol(F, Decl(es6modulekindWithES5Target12.ts, 29, 1), Decl(es6modulekindWithES5Target12.ts, 32, 1)) +>F : Symbol(F, Decl(es6modulekindWithES5Target12.ts, 28, 1), Decl(es6modulekindWithES5Target12.ts, 31, 1)) } export namespace F { ->F : Symbol(F, Decl(es6modulekindWithES5Target12.ts, 29, 1), Decl(es6modulekindWithES5Target12.ts, 32, 1)) +>F : Symbol(F, Decl(es6modulekindWithES5Target12.ts, 28, 1), Decl(es6modulekindWithES5Target12.ts, 31, 1)) export const x = 1; ->x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 35, 16)) +>x : Symbol(x, Decl(es6modulekindWithES5Target12.ts, 34, 16)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target12.types b/tests/baselines/reference/es6modulekindWithES5Target12.types index 5bc42cae68a06..7d38adb3f4679 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target12.types +++ b/tests/baselines/reference/es6modulekindWithES5Target12.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target12.ts === - export class C { >C : C } diff --git a/tests/baselines/reference/es6modulekindWithES5Target2.js b/tests/baselines/reference/es6modulekindWithES5Target2.js index 101ead5cb5607..8b2f6dd3c53de 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target2.js +++ b/tests/baselines/reference/es6modulekindWithES5Target2.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target2.ts] - export default class C { static s = 0; p = 1; diff --git a/tests/baselines/reference/es6modulekindWithES5Target2.symbols b/tests/baselines/reference/es6modulekindWithES5Target2.symbols index 762121612eb95..66f1375e6e5ee 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target2.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target2.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/es6modulekindWithES5Target2.ts === - export default class C { >C : Symbol(C, Decl(es6modulekindWithES5Target2.ts, 0, 0)) static s = 0; ->s : Symbol(C.s, Decl(es6modulekindWithES5Target2.ts, 1, 24)) +>s : Symbol(C.s, Decl(es6modulekindWithES5Target2.ts, 0, 24)) p = 1; ->p : Symbol(C.p, Decl(es6modulekindWithES5Target2.ts, 2, 17)) +>p : Symbol(C.p, Decl(es6modulekindWithES5Target2.ts, 1, 17)) method() { } ->method : Symbol(C.method, Decl(es6modulekindWithES5Target2.ts, 3, 10)) +>method : Symbol(C.method, Decl(es6modulekindWithES5Target2.ts, 2, 10)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target2.types b/tests/baselines/reference/es6modulekindWithES5Target2.types index 6ad697e0c25ad..6540471c89006 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target2.types +++ b/tests/baselines/reference/es6modulekindWithES5Target2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target2.ts === - export default class C { >C : C diff --git a/tests/baselines/reference/es6modulekindWithES5Target3.js b/tests/baselines/reference/es6modulekindWithES5Target3.js index 72e6f97a90069..87dd04090970f 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target3.js +++ b/tests/baselines/reference/es6modulekindWithES5Target3.js @@ -1,6 +1,4 @@ //// [es6modulekindWithES5Target3.ts] - - declare function foo(...args: any[]): any; @foo export default class D { diff --git a/tests/baselines/reference/es6modulekindWithES5Target3.symbols b/tests/baselines/reference/es6modulekindWithES5Target3.symbols index 3fd26b9033fa9..cc0b1ecc89dd2 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target3.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target3.symbols @@ -1,22 +1,20 @@ === tests/cases/compiler/es6modulekindWithES5Target3.ts === - - declare function foo(...args: any[]): any; >foo : Symbol(foo, Decl(es6modulekindWithES5Target3.ts, 0, 0)) ->args : Symbol(args, Decl(es6modulekindWithES5Target3.ts, 2, 21)) +>args : Symbol(args, Decl(es6modulekindWithES5Target3.ts, 0, 21)) @foo >foo : Symbol(foo, Decl(es6modulekindWithES5Target3.ts, 0, 0)) export default class D { ->D : Symbol(D, Decl(es6modulekindWithES5Target3.ts, 2, 42)) +>D : Symbol(D, Decl(es6modulekindWithES5Target3.ts, 0, 42)) static s = 0; ->s : Symbol(D.s, Decl(es6modulekindWithES5Target3.ts, 4, 24)) +>s : Symbol(D.s, Decl(es6modulekindWithES5Target3.ts, 2, 24)) p = 1; ->p : Symbol(D.p, Decl(es6modulekindWithES5Target3.ts, 5, 17)) +>p : Symbol(D.p, Decl(es6modulekindWithES5Target3.ts, 3, 17)) method() { } ->method : Symbol(D.method, Decl(es6modulekindWithES5Target3.ts, 6, 10)) +>method : Symbol(D.method, Decl(es6modulekindWithES5Target3.ts, 4, 10)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target3.types b/tests/baselines/reference/es6modulekindWithES5Target3.types index 78928f56dddc0..d2cc641b732f1 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target3.types +++ b/tests/baselines/reference/es6modulekindWithES5Target3.types @@ -1,6 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target3.ts === - - declare function foo(...args: any[]): any; >foo : (...args: any[]) => any >args : any[] diff --git a/tests/baselines/reference/es6modulekindWithES5Target4.js b/tests/baselines/reference/es6modulekindWithES5Target4.js index b34e68b811116..15b534fe1080e 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target4.js +++ b/tests/baselines/reference/es6modulekindWithES5Target4.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target4.ts] - class E { } export default E; diff --git a/tests/baselines/reference/es6modulekindWithES5Target4.symbols b/tests/baselines/reference/es6modulekindWithES5Target4.symbols index fdf5bdc619748..f7ff2d0701647 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target4.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target4.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target4.ts === - class E { } >E : Symbol(E, Decl(es6modulekindWithES5Target4.ts, 0, 0)) diff --git a/tests/baselines/reference/es6modulekindWithES5Target4.types b/tests/baselines/reference/es6modulekindWithES5Target4.types index cd0852cab1a19..20bea4e397b59 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target4.types +++ b/tests/baselines/reference/es6modulekindWithES5Target4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target4.ts === - class E { } >E : E diff --git a/tests/baselines/reference/es6modulekindWithES5Target5.js b/tests/baselines/reference/es6modulekindWithES5Target5.js index 735604861839d..14cacaffe406c 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target5.js +++ b/tests/baselines/reference/es6modulekindWithES5Target5.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target5.ts] - export enum E1 { value1 } diff --git a/tests/baselines/reference/es6modulekindWithES5Target5.symbols b/tests/baselines/reference/es6modulekindWithES5Target5.symbols index 5a305ad0f7fba..d4401b86d6b12 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target5.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target5.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/es6modulekindWithES5Target5.ts === - export enum E1 { >E1 : Symbol(E1, Decl(es6modulekindWithES5Target5.ts, 0, 0)) value1 ->value1 : Symbol(E1.value1, Decl(es6modulekindWithES5Target5.ts, 1, 16)) +>value1 : Symbol(E1.value1, Decl(es6modulekindWithES5Target5.ts, 0, 16)) } export const enum E2 { ->E2 : Symbol(E2, Decl(es6modulekindWithES5Target5.ts, 3, 1)) +>E2 : Symbol(E2, Decl(es6modulekindWithES5Target5.ts, 2, 1)) value1 ->value1 : Symbol(E2.value1, Decl(es6modulekindWithES5Target5.ts, 5, 22)) +>value1 : Symbol(E2.value1, Decl(es6modulekindWithES5Target5.ts, 4, 22)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target5.types b/tests/baselines/reference/es6modulekindWithES5Target5.types index 284c72cc0ea6d..5abe6f5b16540 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target5.types +++ b/tests/baselines/reference/es6modulekindWithES5Target5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target5.ts === - export enum E1 { >E1 : E1 diff --git a/tests/baselines/reference/es6modulekindWithES5Target6.js b/tests/baselines/reference/es6modulekindWithES5Target6.js index cff2327dacba8..b57b38d17edc6 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target6.js +++ b/tests/baselines/reference/es6modulekindWithES5Target6.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target6.ts] - export function f1(d = 0) { } diff --git a/tests/baselines/reference/es6modulekindWithES5Target6.symbols b/tests/baselines/reference/es6modulekindWithES5Target6.symbols index 6e779355f3dc5..b07af7462baad 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target6.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target6.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/es6modulekindWithES5Target6.ts === - export function f1(d = 0) { >f1 : Symbol(f1, Decl(es6modulekindWithES5Target6.ts, 0, 0)) ->d : Symbol(d, Decl(es6modulekindWithES5Target6.ts, 1, 19)) +>d : Symbol(d, Decl(es6modulekindWithES5Target6.ts, 0, 19)) } export function f2(...arg) { ->f2 : Symbol(f2, Decl(es6modulekindWithES5Target6.ts, 2, 1)) ->arg : Symbol(arg, Decl(es6modulekindWithES5Target6.ts, 4, 19)) +>f2 : Symbol(f2, Decl(es6modulekindWithES5Target6.ts, 1, 1)) +>arg : Symbol(arg, Decl(es6modulekindWithES5Target6.ts, 3, 19)) } export default function f3(d = 0) { ->f3 : Symbol(f3, Decl(es6modulekindWithES5Target6.ts, 5, 1)) ->d : Symbol(d, Decl(es6modulekindWithES5Target6.ts, 7, 27)) +>f3 : Symbol(f3, Decl(es6modulekindWithES5Target6.ts, 4, 1)) +>d : Symbol(d, Decl(es6modulekindWithES5Target6.ts, 6, 27)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target6.types b/tests/baselines/reference/es6modulekindWithES5Target6.types index de43a987d4d50..5296f4730b34a 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target6.types +++ b/tests/baselines/reference/es6modulekindWithES5Target6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target6.ts === - export function f1(d = 0) { >f1 : (d?: number) => void >d : number diff --git a/tests/baselines/reference/es6modulekindWithES5Target7.js b/tests/baselines/reference/es6modulekindWithES5Target7.js index e3e0b4f454976..5d85c9263d486 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target7.js +++ b/tests/baselines/reference/es6modulekindWithES5Target7.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target7.ts] - export namespace N { var x = 0; } diff --git a/tests/baselines/reference/es6modulekindWithES5Target7.symbols b/tests/baselines/reference/es6modulekindWithES5Target7.symbols index 4bf587dd5d3d8..bcc89efaeaba0 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target7.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target7.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/es6modulekindWithES5Target7.ts === - export namespace N { >N : Symbol(N, Decl(es6modulekindWithES5Target7.ts, 0, 0)) var x = 0; ->x : Symbol(x, Decl(es6modulekindWithES5Target7.ts, 2, 7)) +>x : Symbol(x, Decl(es6modulekindWithES5Target7.ts, 1, 7)) } export namespace N2 { ->N2 : Symbol(N2, Decl(es6modulekindWithES5Target7.ts, 3, 1)) +>N2 : Symbol(N2, Decl(es6modulekindWithES5Target7.ts, 2, 1)) export interface I { } ->I : Symbol(I, Decl(es6modulekindWithES5Target7.ts, 5, 21)) +>I : Symbol(I, Decl(es6modulekindWithES5Target7.ts, 4, 21)) } diff --git a/tests/baselines/reference/es6modulekindWithES5Target7.types b/tests/baselines/reference/es6modulekindWithES5Target7.types index 1c3add3b03110..0e534b85c5497 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target7.types +++ b/tests/baselines/reference/es6modulekindWithES5Target7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target7.ts === - export namespace N { >N : typeof N diff --git a/tests/baselines/reference/es6modulekindWithES5Target8.js b/tests/baselines/reference/es6modulekindWithES5Target8.js index baab6fdab3749..d9a767ec53dc0 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target8.js +++ b/tests/baselines/reference/es6modulekindWithES5Target8.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target8.ts] - export const c = 0; export let l = 1; diff --git a/tests/baselines/reference/es6modulekindWithES5Target8.symbols b/tests/baselines/reference/es6modulekindWithES5Target8.symbols index e85c76a16fe9b..1a5e54ce96dce 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target8.symbols +++ b/tests/baselines/reference/es6modulekindWithES5Target8.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/es6modulekindWithES5Target8.ts === - export const c = 0; ->c : Symbol(c, Decl(es6modulekindWithES5Target8.ts, 1, 12)) +>c : Symbol(c, Decl(es6modulekindWithES5Target8.ts, 0, 12)) export let l = 1; ->l : Symbol(l, Decl(es6modulekindWithES5Target8.ts, 2, 10)) +>l : Symbol(l, Decl(es6modulekindWithES5Target8.ts, 1, 10)) diff --git a/tests/baselines/reference/es6modulekindWithES5Target8.types b/tests/baselines/reference/es6modulekindWithES5Target8.types index 754decea3125a..4bfea977016d9 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target8.types +++ b/tests/baselines/reference/es6modulekindWithES5Target8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/es6modulekindWithES5Target8.ts === - export const c = 0; >c : 0 >0 : 0 diff --git a/tests/baselines/reference/es6modulekindWithES5Target9.errors.txt b/tests/baselines/reference/es6modulekindWithES5Target9.errors.txt index 2e9a35a8783e0..af941e65bbe36 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target9.errors.txt +++ b/tests/baselines/reference/es6modulekindWithES5Target9.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/es6modulekindWithES5Target9.ts(2,15): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target9.ts(4,17): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target9.ts(6,20): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target9.ts(14,15): error TS2307: Cannot find module 'mod'. -tests/cases/compiler/es6modulekindWithES5Target9.ts(16,17): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(1,15): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(3,17): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(5,20): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(13,15): error TS2307: Cannot find module 'mod'. +tests/cases/compiler/es6modulekindWithES5Target9.ts(15,17): error TS2307: Cannot find module 'mod'. ==== tests/cases/compiler/es6modulekindWithES5Target9.ts (5 errors) ==== - import d from "mod"; ~~~~~ !!! error TS2307: Cannot find module 'mod'. diff --git a/tests/baselines/reference/es6modulekindWithES5Target9.js b/tests/baselines/reference/es6modulekindWithES5Target9.js index 97991b40b0cb5..8b4886664ed08 100644 --- a/tests/baselines/reference/es6modulekindWithES5Target9.js +++ b/tests/baselines/reference/es6modulekindWithES5Target9.js @@ -1,5 +1,4 @@ //// [es6modulekindWithES5Target9.ts] - import d from "mod"; import {a} from "mod"; diff --git a/tests/baselines/reference/escapedIdentifiers.js b/tests/baselines/reference/escapedIdentifiers.js index b326dbf1ecc04..37dcb2f7798c6 100644 --- a/tests/baselines/reference/escapedIdentifiers.js +++ b/tests/baselines/reference/escapedIdentifiers.js @@ -1,5 +1,4 @@ //// [escapedIdentifiers.ts] - /* 0 .. \u0030 9 .. \u0039 diff --git a/tests/baselines/reference/escapedIdentifiers.symbols b/tests/baselines/reference/escapedIdentifiers.symbols index 735dede00e2d0..e414f9cf0f7fe 100644 --- a/tests/baselines/reference/escapedIdentifiers.symbols +++ b/tests/baselines/reference/escapedIdentifiers.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/escapedIdentifiers.ts === - /* 0 .. \u0030 9 .. \u0039 @@ -13,222 +12,222 @@ // var decl var \u0061 = 1; ->\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3)) +>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3)) a ++; ->a : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3)) +>a : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3)) \u0061 ++; ->\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3)) +>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3)) var b = 1; ->b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3)) +>b : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3)) b ++; ->b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3)) +>b : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3)) \u0062 ++; ->\u0062 : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3)) +>\u0062 : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3)) // modules module moduleType1 { ->moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10)) +>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10)) export var baz1: number; ->baz1 : Symbol(baz1, Decl(escapedIdentifiers.ts, 23, 14)) +>baz1 : Symbol(baz1, Decl(escapedIdentifiers.ts, 22, 14)) } module moduleType\u0032 { ->moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1)) +>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1)) export var baz2: number; ->baz2 : Symbol(baz2, Decl(escapedIdentifiers.ts, 26, 14)) +>baz2 : Symbol(baz2, Decl(escapedIdentifiers.ts, 25, 14)) } moduleType1.baz1 = 3; ->moduleType1.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) ->moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10)) ->baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) +>moduleType1.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) +>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10)) +>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) moduleType\u0031.baz1 = 3; ->moduleType\u0031.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) ->moduleType\u0031 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10)) ->baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) +>moduleType\u0031.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) +>moduleType\u0031 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10)) +>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) moduleType2.baz2 = 3; ->moduleType2.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) ->moduleType2 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1)) ->baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) +>moduleType2.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) +>moduleType2 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1)) +>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) moduleType\u0032.baz2 = 3; ->moduleType\u0032.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) ->moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1)) ->baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) +>moduleType\u0032.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) +>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1)) +>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) // classes class classType1 { ->classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26)) +>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26)) public foo1: number; ->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) +>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) } class classType\u0032 { ->classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1)) +>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1)) public foo2: number; ->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) +>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) } var classType1Object1 = new classType1(); ->classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3)) ->classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26)) +>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 42, 3)) +>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26)) classType1Object1.foo1 = 2; ->classType1Object1.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) ->classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3)) ->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) +>classType1Object1.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) +>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 42, 3)) +>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) var classType1Object2 = new classType\u0031(); ->classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3)) ->classType\u0031 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26)) +>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 44, 3)) +>classType\u0031 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26)) classType1Object2.foo1 = 2; ->classType1Object2.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) ->classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3)) ->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) +>classType1Object2.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) +>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 44, 3)) +>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) var classType2Object1 = new classType2(); ->classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3)) ->classType2 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1)) +>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 46, 3)) +>classType2 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1)) classType2Object1.foo2 = 2; ->classType2Object1.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) ->classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3)) ->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) +>classType2Object1.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) +>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 46, 3)) +>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) var classType2Object2 = new classType\u0032(); ->classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3)) ->classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1)) +>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 48, 3)) +>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1)) classType2Object2.foo2 = 2; ->classType2Object2.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) ->classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3)) ->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) +>classType2Object2.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) +>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 48, 3)) +>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) // interfaces interface interfaceType1 { ->interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27)) +>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27)) bar1: number; ->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) +>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) } interface interfaceType\u0032 { ->interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1)) +>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1)) bar2: number; ->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) +>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) } var interfaceType1Object1 = { bar1: 0 }; ->interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3)) ->interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27)) ->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 60, 45)) +>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3)) +>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27)) +>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 59, 45)) interfaceType1Object1.bar1 = 2; ->interfaceType1Object1.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) ->interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3)) ->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) +>interfaceType1Object1.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) +>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3)) +>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) var interfaceType1Object2 = { bar1: 0 }; ->interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3)) ->interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27)) ->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 62, 50)) +>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3)) +>interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27)) +>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 61, 50)) interfaceType1Object2.bar1 = 2; ->interfaceType1Object2.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) ->interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3)) ->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) +>interfaceType1Object2.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) +>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3)) +>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) var interfaceType2Object1 = { bar2: 0 }; ->interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3)) ->interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1)) ->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 64, 45)) +>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3)) +>interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1)) +>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 63, 45)) interfaceType2Object1.bar2 = 2; ->interfaceType2Object1.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) ->interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3)) ->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) +>interfaceType2Object1.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) +>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3)) +>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) var interfaceType2Object2 = { bar2: 0 }; ->interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3)) ->interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1)) ->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 66, 50)) +>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3)) +>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1)) +>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 65, 50)) interfaceType2Object2.bar2 = 2; ->interfaceType2Object2.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) ->interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3)) ->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) +>interfaceType2Object2.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) +>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3)) +>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) // arguments class testClass { ->testClass : Symbol(testClass, Decl(escapedIdentifiers.ts, 67, 31)) +>testClass : Symbol(testClass, Decl(escapedIdentifiers.ts, 66, 31)) public func(arg1: number, arg\u0032: string, arg\u0033: boolean, arg4: number) { ->func : Symbol(testClass.func, Decl(escapedIdentifiers.ts, 71, 17)) ->arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16)) ->arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29)) ->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48)) ->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68)) +>func : Symbol(testClass.func, Decl(escapedIdentifiers.ts, 70, 17)) +>arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 71, 16)) +>arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 71, 29)) +>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 71, 48)) +>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 71, 68)) arg\u0031 = 1; ->arg\u0031 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16)) +>arg\u0031 : Symbol(arg1, Decl(escapedIdentifiers.ts, 71, 16)) arg2 = 'string'; ->arg2 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29)) +>arg2 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 71, 29)) arg\u0033 = true; ->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48)) +>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 71, 48)) arg4 = 2; ->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68)) +>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 71, 68)) } } // constructors class constructorTestClass { ->constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1)) +>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 77, 1)) constructor (public arg1: number,public arg\u0032: string,public arg\u0033: boolean,public arg4: number) { ->arg1 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17)) ->arg\u0032 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37)) ->arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62)) ->arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88)) +>arg1 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17)) +>arg\u0032 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37)) +>arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62)) +>arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88)) } } var constructorTestObject = new constructorTestClass(1, 'string', true, 2); ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 77, 1)) constructorTestObject.arg\u0031 = 1; ->constructorTestObject.arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17)) +>constructorTestObject.arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17)) constructorTestObject.arg2 = 'string'; ->constructorTestObject.arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37)) +>constructorTestObject.arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37)) constructorTestObject.arg\u0033 = true; ->constructorTestObject.arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62)) +>constructorTestObject.arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62)) constructorTestObject.arg4 = 2; ->constructorTestObject.arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) ->arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88)) +>constructorTestObject.arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) +>arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88)) // Lables diff --git a/tests/baselines/reference/escapedIdentifiers.types b/tests/baselines/reference/escapedIdentifiers.types index e7f19d7144c3d..6d48bb3392f3e 100644 --- a/tests/baselines/reference/escapedIdentifiers.types +++ b/tests/baselines/reference/escapedIdentifiers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/escapedIdentifiers.ts === - /* 0 .. \u0030 9 .. \u0039 diff --git a/tests/baselines/reference/excessPropertyErrorsSuppressed.js b/tests/baselines/reference/excessPropertyErrorsSuppressed.js index 1673674c5f320..57116704b133b 100644 --- a/tests/baselines/reference/excessPropertyErrorsSuppressed.js +++ b/tests/baselines/reference/excessPropertyErrorsSuppressed.js @@ -1,5 +1,4 @@ //// [excessPropertyErrorsSuppressed.ts] - var x: { a: string } = { a: "hello", b: 42 }; // No error diff --git a/tests/baselines/reference/excessPropertyErrorsSuppressed.symbols b/tests/baselines/reference/excessPropertyErrorsSuppressed.symbols index 01c2846d3e190..9768ed19e4405 100644 --- a/tests/baselines/reference/excessPropertyErrorsSuppressed.symbols +++ b/tests/baselines/reference/excessPropertyErrorsSuppressed.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/excessPropertyErrorsSuppressed.ts === - var x: { a: string } = { a: "hello", b: 42 }; // No error ->x : Symbol(x, Decl(excessPropertyErrorsSuppressed.ts, 1, 3)) ->a : Symbol(a, Decl(excessPropertyErrorsSuppressed.ts, 1, 8)) ->a : Symbol(a, Decl(excessPropertyErrorsSuppressed.ts, 1, 24)) ->b : Symbol(b, Decl(excessPropertyErrorsSuppressed.ts, 1, 36)) +>x : Symbol(x, Decl(excessPropertyErrorsSuppressed.ts, 0, 3)) +>a : Symbol(a, Decl(excessPropertyErrorsSuppressed.ts, 0, 8)) +>a : Symbol(a, Decl(excessPropertyErrorsSuppressed.ts, 0, 24)) +>b : Symbol(b, Decl(excessPropertyErrorsSuppressed.ts, 0, 36)) diff --git a/tests/baselines/reference/excessPropertyErrorsSuppressed.types b/tests/baselines/reference/excessPropertyErrorsSuppressed.types index c0b8f66d84048..e1288e969c109 100644 --- a/tests/baselines/reference/excessPropertyErrorsSuppressed.types +++ b/tests/baselines/reference/excessPropertyErrorsSuppressed.types @@ -1,5 +1,4 @@ === tests/cases/compiler/excessPropertyErrorsSuppressed.ts === - var x: { a: string } = { a: "hello", b: 42 }; // No error >x : { a: string; } >a : string diff --git a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.js b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.js index 218d760d6c51a..317629c4cb88c 100644 --- a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.js +++ b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.js @@ -1,5 +1,4 @@ //// [exhaustiveSwitchWithWideningLiteralTypes.ts] - // Repro from #12529 class A { diff --git a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.symbols b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.symbols index 929a394dc7bee..e54d4bca63b9f 100644 --- a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.symbols +++ b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/exhaustiveSwitchWithWideningLiteralTypes.ts === - // Repro from #12529 class A { >A : Symbol(A, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 0, 0)) readonly kind = "A"; // (property) A.kind: "A" ->kind : Symbol(A.kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 3, 9)) +>kind : Symbol(A.kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 2, 9)) } class B { ->B : Symbol(B, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 5, 1)) +>B : Symbol(B, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 4, 1)) readonly kind = "B"; // (property) B.kind: "B" ->kind : Symbol(B.kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 7, 9)) +>kind : Symbol(B.kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 6, 9)) } function f(value: A | B): number { ->f : Symbol(f, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 9, 1)) ->value : Symbol(value, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 11, 11)) +>f : Symbol(f, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 8, 1)) +>value : Symbol(value, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 10, 11)) >A : Symbol(A, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 0, 0)) ->B : Symbol(B, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 5, 1)) +>B : Symbol(B, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 4, 1)) switch(value.kind) { ->value.kind : Symbol(kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 3, 9), Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 7, 9)) ->value : Symbol(value, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 11, 11)) ->kind : Symbol(kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 3, 9), Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 7, 9)) +>value.kind : Symbol(kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 2, 9), Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 6, 9)) +>value : Symbol(value, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 10, 11)) +>kind : Symbol(kind, Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 2, 9), Decl(exhaustiveSwitchWithWideningLiteralTypes.ts, 6, 9)) case "A": return 0; case "B": return 1; diff --git a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.types b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.types index 3955c80ff1e88..8bafad04544a7 100644 --- a/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.types +++ b/tests/baselines/reference/exhaustiveSwitchWithWideningLiteralTypes.types @@ -1,5 +1,4 @@ === tests/cases/compiler/exhaustiveSwitchWithWideningLiteralTypes.ts === - // Repro from #12529 class A { diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt index c20e4b1900886..86410b1b49148 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt @@ -1,52 +1,51 @@ -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(8,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(8,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(7,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(7,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(8,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(9,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(10,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(11,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(11,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(11,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(12,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(12,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(13,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(13,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(12,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(14,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(14,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(15,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(15,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(15,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(16,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(16,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(21,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(21,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(22,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(22,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(22,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(23,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(23,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts (45 errors) ==== - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js index 8c6d9e011f613..8a793b4e780cf 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorInTemplateStringWithSyntaxError1.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt index 015d1f6d6f002..7d3651498c580 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt @@ -1,52 +1,51 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(7,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(8,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(9,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(10,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(10,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(10,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(11,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(11,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(13,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(13,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(11,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(14,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(14,27): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(15,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(15,27): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(15,29): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(16,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(16,29): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,29): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,31): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,31): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,31): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,31): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,34): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,34): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,42): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,42): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,34): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,34): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,42): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,42): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(21,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(21,40): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(22,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(22,40): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(22,42): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(23,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(23,42): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,42): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,44): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,44): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,44): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,44): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,47): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,47): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,55): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,55): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,47): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,47): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,55): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,55): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts (45 errors) ==== - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js index 9ae2d72707814..cf8bcfd698fe4 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorInTemplateStringWithSyntaxError2.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt index 320d9a4d309d9..0c6fab96f9063 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt @@ -1,52 +1,51 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(7,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(8,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(9,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(10,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(10,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(10,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(11,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(11,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(13,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(13,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(11,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(14,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(14,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(15,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(15,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(15,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(16,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(16,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(21,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(21,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(22,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(22,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(22,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(23,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(23,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts (45 errors) ==== - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js index c3711ac281ca6..bb203db9144a7 100644 --- a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js +++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorInTemplateStringWithSyntaxError3.ts] - var t1 = 10; var t2 = 10; var s; diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt b/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt index 4b56e4f4258ee..76d20997f6deb 100644 --- a/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt @@ -1,38 +1,37 @@ -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(3,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(4,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(2,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(3,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(4,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(5,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(6,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(6,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(6,7): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(7,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(7,7): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(8,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(12,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(13,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(14,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(15,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(16,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(17,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(18,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(19,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(11,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(12,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(13,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(14,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(15,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(16,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(17,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(18,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(20,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(21,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(22,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(23,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(24,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(24,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(25,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(26,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(27,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(28,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(28,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(29,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(30,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(31,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(32,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(32,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(33,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(34,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(35,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(36,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts (31 errors) ==== - // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () -1 ** 2; ~~ diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError1.js b/tests/baselines/reference/exponentiationOperatorSyntaxError1.js index 059941516102a..667abed731c48 100644 --- a/tests/baselines/reference/exponentiationOperatorSyntaxError1.js +++ b/tests/baselines/reference/exponentiationOperatorSyntaxError1.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorSyntaxError1.ts] - // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () -1 ** 2; +1 ** 2 @@ -41,7 +40,8 @@ var temp = 10; //// [exponentiationOperatorSyntaxError1.js] // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () -Math.pow(-1, 2); +Math.pow(// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () +-1, 2); Math.pow(+1, 2); Math.pow(1, Math.pow(-2, 3)); Math.pow(1, Math.pow(-2, -3)); diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt b/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt index 057ceb0c71d05..f144879002e2a 100644 --- a/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt @@ -1,3 +1,6 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(4,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(4,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(4,8): error TS2703: The operand of a delete operator must be a property reference. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(5,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(5,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(5,8): error TS2703: The operand of a delete operator must be a property reference. @@ -7,9 +10,9 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(7,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(7,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(7,8): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(8,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(8,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(8,8): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(10,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(10,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(10,13): error TS2703: The operand of a delete operator must be a property reference. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(11,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(11,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(11,13): error TS2703: The operand of a delete operator must be a property reference. @@ -19,9 +22,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(13,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(13,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(13,13): error TS2703: The operand of a delete operator must be a property reference. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(14,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(14,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(14,13): error TS2703: The operand of a delete operator must be a property reference. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(15,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(15,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(16,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(16,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(17,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. @@ -30,8 +32,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(18,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(19,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(19,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(20,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(20,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(21,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(21,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(22,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(22,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(23,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. @@ -40,8 +42,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(24,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(25,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(25,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(26,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(26,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(27,1): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(27,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(28,1): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(28,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(29,1): error TS2532: Object is possibly 'undefined'. @@ -50,8 +52,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(30,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(31,1): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(31,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(32,1): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(32,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(33,6): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(33,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(34,6): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(34,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(35,6): error TS2532: Object is possibly 'undefined'. @@ -60,18 +62,18 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(36,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(37,6): error TS2532: Object is possibly 'undefined'. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(37,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(38,6): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(38,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(39,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(40,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(41,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(42,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(43,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(44,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(45,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(46,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(47,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(48,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(49,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(50,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(51,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(51,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(52,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(52,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(53,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. @@ -80,8 +82,8 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(54,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(55,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(55,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(56,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(56,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(57,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(57,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(58,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(58,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(59,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. @@ -90,17 +92,14 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(60,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(61,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(61,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(62,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(62,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(63,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(64,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(65,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(66,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(67,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(68,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts (99 errors) ==== - // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () var temp: any; diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError2.js b/tests/baselines/reference/exponentiationOperatorSyntaxError2.js index e443b756575f6..aad09c8e26d29 100644 --- a/tests/baselines/reference/exponentiationOperatorSyntaxError2.js +++ b/tests/baselines/reference/exponentiationOperatorSyntaxError2.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorSyntaxError2.ts] - // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without () var temp: any; diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt index 53379f29933c1..5c659f24508c5 100644 --- a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt @@ -1,19 +1,18 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(1,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(2,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(3,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(4,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(5,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(5,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(6,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(9,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(11,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(12,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(13,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(14,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(15,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts (12 errors) ==== - var a = 1 ** `${ 3 }`; ~~~~~~~~ !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js index 5bd9a9609a059..530a106d09db1 100644 --- a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js +++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorWithTemplateStringInvalid.ts] - var a = 1 ** `${ 3 }`; var b = 1 ** `2${ 3 }`; var c = 1 ** `${ 3 }4`; diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt index 39ade9df20531..ed26fd48c7576 100644 --- a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt +++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt @@ -1,20 +1,19 @@ +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(1,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(2,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(3,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(4,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(5,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(5,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(6,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(9,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(11,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(12,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(13,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(14,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(15,1): error TS2304: Cannot find name 'kj'. -tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(15,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(14,1): error TS2304: Cannot find name 'kj'. +tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(14,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts (13 errors) ==== - var a = 1 ** `${ 3 }`; ~~~~~~~~ !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js index cde5133039f0f..2f1e7356536cd 100644 --- a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js +++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js @@ -1,5 +1,4 @@ //// [exponentiationOperatorWithTemplateStringInvalidES6.ts] - var a = 1 ** `${ 3 }`; var b = 1 ** `2${ 3 }`; var c = 1 ** `${ 3 }4`; diff --git a/tests/baselines/reference/exportAndImport-es3-amd.js b/tests/baselines/reference/exportAndImport-es3-amd.js index d19de0c78b07b..ff341f922b5f2 100644 --- a/tests/baselines/reference/exportAndImport-es3-amd.js +++ b/tests/baselines/reference/exportAndImport-es3-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportAndImport-es3-amd.ts] //// //// [m1.ts] - export default function f1() { } diff --git a/tests/baselines/reference/exportAndImport-es3-amd.symbols b/tests/baselines/reference/exportAndImport-es3-amd.symbols index 66e516598410f..b8d336ab3a1a8 100644 --- a/tests/baselines/reference/exportAndImport-es3-amd.symbols +++ b/tests/baselines/reference/exportAndImport-es3-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : Symbol(f1, Decl(m1.ts, 0, 0)) } diff --git a/tests/baselines/reference/exportAndImport-es3-amd.types b/tests/baselines/reference/exportAndImport-es3-amd.types index 48136c8779d68..b70c5171f006c 100644 --- a/tests/baselines/reference/exportAndImport-es3-amd.types +++ b/tests/baselines/reference/exportAndImport-es3-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : () => void } diff --git a/tests/baselines/reference/exportAndImport-es3.js b/tests/baselines/reference/exportAndImport-es3.js index 13b6f1eaf4804..48b3e94a2f218 100644 --- a/tests/baselines/reference/exportAndImport-es3.js +++ b/tests/baselines/reference/exportAndImport-es3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportAndImport-es3.ts] //// //// [m1.ts] - export default function f1() { } diff --git a/tests/baselines/reference/exportAndImport-es3.symbols b/tests/baselines/reference/exportAndImport-es3.symbols index 746f89927b2e4..7f947a5f4d45a 100644 --- a/tests/baselines/reference/exportAndImport-es3.symbols +++ b/tests/baselines/reference/exportAndImport-es3.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : Symbol(f1, Decl(m1.ts, 0, 0)) } diff --git a/tests/baselines/reference/exportAndImport-es3.types b/tests/baselines/reference/exportAndImport-es3.types index 9bae430e23173..8414696adca91 100644 --- a/tests/baselines/reference/exportAndImport-es3.types +++ b/tests/baselines/reference/exportAndImport-es3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : () => void } diff --git a/tests/baselines/reference/exportAndImport-es5-amd.js b/tests/baselines/reference/exportAndImport-es5-amd.js index 60b1246b616dc..d471d76da51a6 100644 --- a/tests/baselines/reference/exportAndImport-es5-amd.js +++ b/tests/baselines/reference/exportAndImport-es5-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportAndImport-es5-amd.ts] //// //// [m1.ts] - export default function f1() { } diff --git a/tests/baselines/reference/exportAndImport-es5-amd.symbols b/tests/baselines/reference/exportAndImport-es5-amd.symbols index 66e516598410f..b8d336ab3a1a8 100644 --- a/tests/baselines/reference/exportAndImport-es5-amd.symbols +++ b/tests/baselines/reference/exportAndImport-es5-amd.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : Symbol(f1, Decl(m1.ts, 0, 0)) } diff --git a/tests/baselines/reference/exportAndImport-es5-amd.types b/tests/baselines/reference/exportAndImport-es5-amd.types index 48136c8779d68..b70c5171f006c 100644 --- a/tests/baselines/reference/exportAndImport-es5-amd.types +++ b/tests/baselines/reference/exportAndImport-es5-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : () => void } diff --git a/tests/baselines/reference/exportAndImport-es5.js b/tests/baselines/reference/exportAndImport-es5.js index f4bc496e6b254..c329b650d6e55 100644 --- a/tests/baselines/reference/exportAndImport-es5.js +++ b/tests/baselines/reference/exportAndImport-es5.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportAndImport-es5.ts] //// //// [m1.ts] - export default function f1() { } diff --git a/tests/baselines/reference/exportAndImport-es5.symbols b/tests/baselines/reference/exportAndImport-es5.symbols index 66e516598410f..b8d336ab3a1a8 100644 --- a/tests/baselines/reference/exportAndImport-es5.symbols +++ b/tests/baselines/reference/exportAndImport-es5.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : Symbol(f1, Decl(m1.ts, 0, 0)) } diff --git a/tests/baselines/reference/exportAndImport-es5.types b/tests/baselines/reference/exportAndImport-es5.types index 48136c8779d68..b70c5171f006c 100644 --- a/tests/baselines/reference/exportAndImport-es5.types +++ b/tests/baselines/reference/exportAndImport-es5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f1() { >f1 : () => void } diff --git a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.js b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.js index d4b6961cfe95a..2d36cffdd176e 100644 --- a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.js +++ b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportAssignedTypeAsTypeAnnotation.ts] //// //// [exportAssignedTypeAsTypeAnnotation_0.ts] - interface x { (): Date; foo: string; diff --git a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols index 79392369c3fbd..c383b8fd9e0bf 100644 --- a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols +++ b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols @@ -8,7 +8,6 @@ var t2: test; // should not raise a 'container type' error >test : Symbol(test, Decl(exportAssignedTypeAsTypeAnnotation_1.ts, 0, 0)) === tests/cases/compiler/exportAssignedTypeAsTypeAnnotation_0.ts === - interface x { >x : Symbol(x, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 0, 0)) @@ -16,7 +15,7 @@ interface x { >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo: string; ->foo : Symbol(x.foo, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 2, 13)) +>foo : Symbol(x.foo, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 1, 13)) } export = x; >x : Symbol(x, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 0, 0)) diff --git a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.types b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.types index 553dbe35c4fca..2245808b22650 100644 --- a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.types +++ b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.types @@ -8,7 +8,6 @@ var t2: test; // should not raise a 'container type' error >test : test === tests/cases/compiler/exportAssignedTypeAsTypeAnnotation_0.ts === - interface x { >x : x diff --git a/tests/baselines/reference/exportCodeGen.js b/tests/baselines/reference/exportCodeGen.js index d72c633731df5..9adde81e0feb0 100644 --- a/tests/baselines/reference/exportCodeGen.js +++ b/tests/baselines/reference/exportCodeGen.js @@ -1,5 +1,4 @@ //// [exportCodeGen.ts] - // should replace all refs to 'x' in the body, // with fully qualified module A { diff --git a/tests/baselines/reference/exportCodeGen.symbols b/tests/baselines/reference/exportCodeGen.symbols index b664704d04978..bc390bc83e001 100644 --- a/tests/baselines/reference/exportCodeGen.symbols +++ b/tests/baselines/reference/exportCodeGen.symbols @@ -1,42 +1,41 @@ === tests/cases/conformance/internalModules/codeGeneration/exportCodeGen.ts === - // should replace all refs to 'x' in the body, // with fully qualified module A { >A : Symbol(A, Decl(exportCodeGen.ts, 0, 0)) export var x = 12; ->x : Symbol(x, Decl(exportCodeGen.ts, 4, 14)) +>x : Symbol(x, Decl(exportCodeGen.ts, 3, 14)) function lt12() { ->lt12 : Symbol(lt12, Decl(exportCodeGen.ts, 4, 22)) +>lt12 : Symbol(lt12, Decl(exportCodeGen.ts, 3, 22)) return x < 12; ->x : Symbol(x, Decl(exportCodeGen.ts, 4, 14)) +>x : Symbol(x, Decl(exportCodeGen.ts, 3, 14)) } } // should not fully qualify 'x' module B { ->B : Symbol(B, Decl(exportCodeGen.ts, 8, 1)) +>B : Symbol(B, Decl(exportCodeGen.ts, 7, 1)) var x = 12; ->x : Symbol(x, Decl(exportCodeGen.ts, 12, 7)) +>x : Symbol(x, Decl(exportCodeGen.ts, 11, 7)) function lt12() { ->lt12 : Symbol(lt12, Decl(exportCodeGen.ts, 12, 15)) +>lt12 : Symbol(lt12, Decl(exportCodeGen.ts, 11, 15)) return x < 12; ->x : Symbol(x, Decl(exportCodeGen.ts, 12, 7)) +>x : Symbol(x, Decl(exportCodeGen.ts, 11, 7)) } } // not copied, since not exported module C { ->C : Symbol(C, Decl(exportCodeGen.ts, 16, 1)) +>C : Symbol(C, Decl(exportCodeGen.ts, 15, 1)) function no() { ->no : Symbol(no, Decl(exportCodeGen.ts, 19, 10)) +>no : Symbol(no, Decl(exportCodeGen.ts, 18, 10)) return false; } @@ -44,10 +43,10 @@ module C { // copies, since exported module D { ->D : Symbol(D, Decl(exportCodeGen.ts, 23, 1)) +>D : Symbol(D, Decl(exportCodeGen.ts, 22, 1)) export function yes() { ->yes : Symbol(yes, Decl(exportCodeGen.ts, 26, 10)) +>yes : Symbol(yes, Decl(exportCodeGen.ts, 25, 10)) return true; } @@ -55,55 +54,55 @@ module D { // validate all exportable statements module E { ->E : Symbol(E, Decl(exportCodeGen.ts, 30, 1)) +>E : Symbol(E, Decl(exportCodeGen.ts, 29, 1)) export enum Color { Red } ->Color : Symbol(Color, Decl(exportCodeGen.ts, 33, 10)) ->Red : Symbol(Color.Red, Decl(exportCodeGen.ts, 34, 23)) +>Color : Symbol(Color, Decl(exportCodeGen.ts, 32, 10)) +>Red : Symbol(Color.Red, Decl(exportCodeGen.ts, 33, 23)) export function fn() { } ->fn : Symbol(fn, Decl(exportCodeGen.ts, 34, 29)) +>fn : Symbol(fn, Decl(exportCodeGen.ts, 33, 29)) export interface I { id: number } ->I : Symbol(I, Decl(exportCodeGen.ts, 35, 28)) ->id : Symbol(I.id, Decl(exportCodeGen.ts, 36, 24)) +>I : Symbol(I, Decl(exportCodeGen.ts, 34, 28)) +>id : Symbol(I.id, Decl(exportCodeGen.ts, 35, 24)) export class C { name: string } ->C : Symbol(C, Decl(exportCodeGen.ts, 36, 37)) ->name : Symbol(C.name, Decl(exportCodeGen.ts, 37, 20)) +>C : Symbol(C, Decl(exportCodeGen.ts, 35, 37)) +>name : Symbol(C.name, Decl(exportCodeGen.ts, 36, 20)) export module M { ->M : Symbol(M, Decl(exportCodeGen.ts, 37, 35)) +>M : Symbol(M, Decl(exportCodeGen.ts, 36, 35)) export var x = 42; ->x : Symbol(x, Decl(exportCodeGen.ts, 39, 18)) +>x : Symbol(x, Decl(exportCodeGen.ts, 38, 18)) } } // validate all exportable statements, // which are not exported module F { ->F : Symbol(F, Decl(exportCodeGen.ts, 41, 1)) +>F : Symbol(F, Decl(exportCodeGen.ts, 40, 1)) enum Color { Red } ->Color : Symbol(Color, Decl(exportCodeGen.ts, 45, 10)) ->Red : Symbol(Color.Red, Decl(exportCodeGen.ts, 46, 16)) +>Color : Symbol(Color, Decl(exportCodeGen.ts, 44, 10)) +>Red : Symbol(Color.Red, Decl(exportCodeGen.ts, 45, 16)) function fn() { } ->fn : Symbol(fn, Decl(exportCodeGen.ts, 46, 22)) +>fn : Symbol(fn, Decl(exportCodeGen.ts, 45, 22)) interface I { id: number } ->I : Symbol(I, Decl(exportCodeGen.ts, 47, 21)) ->id : Symbol(I.id, Decl(exportCodeGen.ts, 48, 17)) +>I : Symbol(I, Decl(exportCodeGen.ts, 46, 21)) +>id : Symbol(I.id, Decl(exportCodeGen.ts, 47, 17)) class C { name: string } ->C : Symbol(C, Decl(exportCodeGen.ts, 48, 30)) ->name : Symbol(C.name, Decl(exportCodeGen.ts, 49, 13)) +>C : Symbol(C, Decl(exportCodeGen.ts, 47, 30)) +>name : Symbol(C.name, Decl(exportCodeGen.ts, 48, 13)) module M { ->M : Symbol(M, Decl(exportCodeGen.ts, 49, 28)) +>M : Symbol(M, Decl(exportCodeGen.ts, 48, 28)) var x = 42; ->x : Symbol(x, Decl(exportCodeGen.ts, 51, 11)) +>x : Symbol(x, Decl(exportCodeGen.ts, 50, 11)) } } diff --git a/tests/baselines/reference/exportCodeGen.types b/tests/baselines/reference/exportCodeGen.types index 03d4ea0d97709..3aa5c9700c644 100644 --- a/tests/baselines/reference/exportCodeGen.types +++ b/tests/baselines/reference/exportCodeGen.types @@ -1,5 +1,4 @@ === tests/cases/conformance/internalModules/codeGeneration/exportCodeGen.ts === - // should replace all refs to 'x' in the body, // with fully qualified module A { diff --git a/tests/baselines/reference/exportDeclarationInInternalModule.errors.txt b/tests/baselines/reference/exportDeclarationInInternalModule.errors.txt index 58973f2a096b8..ab86e0ee65b68 100644 --- a/tests/baselines/reference/exportDeclarationInInternalModule.errors.txt +++ b/tests/baselines/reference/exportDeclarationInInternalModule.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/exportDeclarationInInternalModule.ts(14,19): error TS1141: String literal expected. +tests/cases/compiler/exportDeclarationInInternalModule.ts(13,19): error TS1141: String literal expected. ==== tests/cases/compiler/exportDeclarationInInternalModule.ts (1 errors) ==== - class Bbb { } diff --git a/tests/baselines/reference/exportDeclarationInInternalModule.js b/tests/baselines/reference/exportDeclarationInInternalModule.js index dde865bd2c75a..7c3345739c302 100644 --- a/tests/baselines/reference/exportDeclarationInInternalModule.js +++ b/tests/baselines/reference/exportDeclarationInInternalModule.js @@ -1,5 +1,4 @@ //// [exportDeclarationInInternalModule.ts] - class Bbb { } diff --git a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.js b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.js index e0165098b20c5..c9c681ac40b3d 100644 --- a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.js +++ b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportDeclarationWithModuleSpecifierNameOnNextLine1.ts] //// //// [t1.ts] - export var x = "x"; //// [t2.ts] diff --git a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.symbols b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.symbols index 331766f7712a6..10644407572b8 100644 --- a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.symbols +++ b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/t1.ts === - export var x = "x"; ->x : Symbol(x, Decl(t1.ts, 1, 10)) +>x : Symbol(x, Decl(t1.ts, 0, 10)) === tests/cases/compiler/t2.ts === export { x } from diff --git a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.types b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.types index ec22904750181..510ccc294680b 100644 --- a/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.types +++ b/tests/baselines/reference/exportDeclarationWithModuleSpecifierNameOnNextLine1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/t1.ts === - export var x = "x"; >x : string >"x" : "x" diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.js b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.js index d458433aed43d..31191e213ef26 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.js +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.js @@ -1,5 +1,4 @@ //// [exportDeclarationsInAmbientNamespaces.ts] - declare namespace Q { function _try(method: Function, ...args: any[]): any; export { _try as try }; diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.symbols b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.symbols index 99e70fe4595b8..4cf100c1fa722 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.symbols +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/exportDeclarationsInAmbientNamespaces.ts === - declare namespace Q { >Q : Symbol(Q, Decl(exportDeclarationsInAmbientNamespaces.ts, 0, 0)) function _try(method: Function, ...args: any[]): any; ->_try : Symbol(_try, Decl(exportDeclarationsInAmbientNamespaces.ts, 1, 21)) ->method : Symbol(method, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 18)) +>_try : Symbol(_try, Decl(exportDeclarationsInAmbientNamespaces.ts, 0, 21)) +>method : Symbol(method, Decl(exportDeclarationsInAmbientNamespaces.ts, 1, 18)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->args : Symbol(args, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 35)) +>args : Symbol(args, Decl(exportDeclarationsInAmbientNamespaces.ts, 1, 35)) export { _try as try }; ->_try : Symbol(try, Decl(exportDeclarationsInAmbientNamespaces.ts, 3, 12)) ->try : Symbol(try, Decl(exportDeclarationsInAmbientNamespaces.ts, 3, 12)) +>_try : Symbol(try, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 12)) +>try : Symbol(try, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 12)) } Q.try(() => { }); ->Q.try : Symbol(Q.try, Decl(exportDeclarationsInAmbientNamespaces.ts, 3, 12)) +>Q.try : Symbol(Q.try, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 12)) >Q : Symbol(Q, Decl(exportDeclarationsInAmbientNamespaces.ts, 0, 0)) ->try : Symbol(Q.try, Decl(exportDeclarationsInAmbientNamespaces.ts, 3, 12)) +>try : Symbol(Q.try, Decl(exportDeclarationsInAmbientNamespaces.ts, 2, 12)) diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.types b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.types index a46d99454f9e5..9c67482186cdf 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.types +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces.types @@ -1,5 +1,4 @@ === tests/cases/compiler/exportDeclarationsInAmbientNamespaces.ts === - declare namespace Q { >Q : typeof Q diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.errors.txt b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.errors.txt index 54c04bd9b1d76..8abb7aa38c467 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.errors.txt +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/exportDeclarationsInAmbientNamespaces2.ts(7,23): error TS1194: Export declarations are not permitted in a namespace. +tests/cases/compiler/exportDeclarationsInAmbientNamespaces2.ts(6,23): error TS1194: Export declarations are not permitted in a namespace. ==== tests/cases/compiler/exportDeclarationsInAmbientNamespaces2.ts (1 errors) ==== - declare module "mod" { export var x: number; } diff --git a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.js b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.js index 6896f13025d63..7970ee74fc5c0 100644 --- a/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.js +++ b/tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.js @@ -1,5 +1,4 @@ //// [exportDeclarationsInAmbientNamespaces2.ts] - declare module "mod" { export var x: number; } diff --git a/tests/baselines/reference/exportDeclaredModule.js b/tests/baselines/reference/exportDeclaredModule.js index 473ebaa0492e0..e0d3b25202546 100644 --- a/tests/baselines/reference/exportDeclaredModule.js +++ b/tests/baselines/reference/exportDeclaredModule.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/externalModules/exportDeclaredModule.ts] //// //// [foo1.ts] - declare module M1 { export var a: string; export function b(): number; diff --git a/tests/baselines/reference/exportDeclaredModule.symbols b/tests/baselines/reference/exportDeclaredModule.symbols index a5259f795d9fd..5230f70a71c75 100644 --- a/tests/baselines/reference/exportDeclaredModule.symbols +++ b/tests/baselines/reference/exportDeclaredModule.symbols @@ -4,20 +4,19 @@ import foo1 = require('./foo1'); var x: number = foo1.b(); >x : Symbol(x, Decl(foo2.ts, 1, 3)) ->foo1.b : Symbol(foo1.b, Decl(foo1.ts, 2, 22)) +>foo1.b : Symbol(foo1.b, Decl(foo1.ts, 1, 22)) >foo1 : Symbol(foo1, Decl(foo2.ts, 0, 0)) ->b : Symbol(foo1.b, Decl(foo1.ts, 2, 22)) +>b : Symbol(foo1.b, Decl(foo1.ts, 1, 22)) === tests/cases/conformance/externalModules/foo1.ts === - declare module M1 { >M1 : Symbol(M1, Decl(foo1.ts, 0, 0)) export var a: string; ->a : Symbol(a, Decl(foo1.ts, 2, 11)) +>a : Symbol(a, Decl(foo1.ts, 1, 11)) export function b(): number; ->b : Symbol(b, Decl(foo1.ts, 2, 22)) +>b : Symbol(b, Decl(foo1.ts, 1, 22)) } export = M1; >M1 : Symbol(M1, Decl(foo1.ts, 0, 0)) diff --git a/tests/baselines/reference/exportDeclaredModule.types b/tests/baselines/reference/exportDeclaredModule.types index 00bb50ffa09fb..93e225852ef77 100644 --- a/tests/baselines/reference/exportDeclaredModule.types +++ b/tests/baselines/reference/exportDeclaredModule.types @@ -10,7 +10,6 @@ var x: number = foo1.b(); >b : () => number === tests/cases/conformance/externalModules/foo1.ts === - declare module M1 { >M1 : typeof M1 diff --git a/tests/baselines/reference/exportDefaultAbstractClass.js b/tests/baselines/reference/exportDefaultAbstractClass.js new file mode 100644 index 0000000000000..c8dba03543dc1 --- /dev/null +++ b/tests/baselines/reference/exportDefaultAbstractClass.js @@ -0,0 +1,21 @@ +//// [tests/cases/compiler/exportDefaultAbstractClass.ts] //// + +//// [a.ts] +export default abstract class A {} + +//// [b.ts] +import A from './a' + + +//// [a.js] +"use strict"; +exports.__esModule = true; +var A = (function () { + function A() { + } + return A; +}()); +exports["default"] = A; +//// [b.js] +"use strict"; +exports.__esModule = true; diff --git a/tests/baselines/reference/exportDefaultAbstractClass.symbols b/tests/baselines/reference/exportDefaultAbstractClass.symbols new file mode 100644 index 0000000000000..75c6c068f08e1 --- /dev/null +++ b/tests/baselines/reference/exportDefaultAbstractClass.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/a.ts === +export default abstract class A {} +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import A from './a' +>A : Symbol(A, Decl(b.ts, 0, 6)) + diff --git a/tests/baselines/reference/exportDefaultAbstractClass.types b/tests/baselines/reference/exportDefaultAbstractClass.types new file mode 100644 index 0000000000000..d400be1af43f3 --- /dev/null +++ b/tests/baselines/reference/exportDefaultAbstractClass.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/a.ts === +export default abstract class A {} +>A : A + +=== tests/cases/compiler/b.ts === +import A from './a' +>A : typeof A + diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.js b/tests/baselines/reference/exportDefaultAsyncFunction2.js index 7b79bed9408ab..8f8893811403d 100644 --- a/tests/baselines/reference/exportDefaultAsyncFunction2.js +++ b/tests/baselines/reference/exportDefaultAsyncFunction2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportDefaultAsyncFunction2.ts] //// //// [asyncawait.ts] - export function async(...args: any[]): any { } export function await(...args: any[]): any { } diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols index cffbf284573b0..02b32f7ee285d 100644 --- a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols +++ b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/asyncawait.ts === - export function async(...args: any[]): any { } >async : Symbol(async, Decl(asyncawait.ts, 0, 0)) ->T : Symbol(T, Decl(asyncawait.ts, 1, 22)) ->args : Symbol(args, Decl(asyncawait.ts, 1, 25)) +>T : Symbol(T, Decl(asyncawait.ts, 0, 22)) +>args : Symbol(args, Decl(asyncawait.ts, 0, 25)) export function await(...args: any[]): any { } ->await : Symbol(await, Decl(asyncawait.ts, 1, 49)) ->args : Symbol(args, Decl(asyncawait.ts, 2, 22)) +>await : Symbol(await, Decl(asyncawait.ts, 0, 49)) +>args : Symbol(args, Decl(asyncawait.ts, 1, 22)) === tests/cases/compiler/a.ts === import { async, await } from 'asyncawait'; diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.types b/tests/baselines/reference/exportDefaultAsyncFunction2.types index a9ff903e53aed..9aad9fb98ec89 100644 --- a/tests/baselines/reference/exportDefaultAsyncFunction2.types +++ b/tests/baselines/reference/exportDefaultAsyncFunction2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/asyncawait.ts === - export function async(...args: any[]): any { } >async : (...args: any[]) => any >T : T diff --git a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.js b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.js index f2b98e6eb4459..c76a7b0806db5 100644 --- a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.js +++ b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.js @@ -1,5 +1,4 @@ //// [exportDefaultForNonInstantiatedModule.ts] - module m { export interface foo { } diff --git a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.symbols b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.symbols index eb0836fd519b8..a0f061a72d06e 100644 --- a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.symbols +++ b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/exportDefaultForNonInstantiatedModule.ts === - module m { >m : Symbol(m, Decl(exportDefaultForNonInstantiatedModule.ts, 0, 0)) export interface foo { ->foo : Symbol(foo, Decl(exportDefaultForNonInstantiatedModule.ts, 1, 10)) +>foo : Symbol(foo, Decl(exportDefaultForNonInstantiatedModule.ts, 0, 10)) } } // Should not be emitted diff --git a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.types b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.types index 6ec8f9868a3f2..388854d9d169e 100644 --- a/tests/baselines/reference/exportDefaultForNonInstantiatedModule.types +++ b/tests/baselines/reference/exportDefaultForNonInstantiatedModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/exportDefaultForNonInstantiatedModule.ts === - module m { >m : any diff --git a/tests/baselines/reference/exportDefaultInJsFile01.errors.txt b/tests/baselines/reference/exportDefaultInJsFile01.errors.txt index 78b2ee664b916..a281df5928966 100644 --- a/tests/baselines/reference/exportDefaultInJsFile01.errors.txt +++ b/tests/baselines/reference/exportDefaultInJsFile01.errors.txt @@ -5,5 +5,4 @@ error TS5055: Cannot write file 'tests/cases/conformance/salsa/myFile01.js' beca !!! error TS5055: Cannot write file 'tests/cases/conformance/salsa/myFile01.js' because it would overwrite input file. !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. ==== tests/cases/conformance/salsa/myFile01.js (0 errors) ==== - export default "hello"; \ No newline at end of file diff --git a/tests/baselines/reference/exportDefaultInJsFile02.errors.txt b/tests/baselines/reference/exportDefaultInJsFile02.errors.txt index f53233a1effef..7155f427b2d28 100644 --- a/tests/baselines/reference/exportDefaultInJsFile02.errors.txt +++ b/tests/baselines/reference/exportDefaultInJsFile02.errors.txt @@ -5,5 +5,4 @@ error TS5055: Cannot write file 'tests/cases/conformance/salsa/myFile02.js' beca !!! error TS5055: Cannot write file 'tests/cases/conformance/salsa/myFile02.js' because it would overwrite input file. !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. ==== tests/cases/conformance/salsa/myFile02.js (0 errors) ==== - export default "hello"; \ No newline at end of file diff --git a/tests/baselines/reference/exportDefaultProperty2.js b/tests/baselines/reference/exportDefaultProperty2.js index 4922738430acf..5cc9dc47092be 100644 --- a/tests/baselines/reference/exportDefaultProperty2.js +++ b/tests/baselines/reference/exportDefaultProperty2.js @@ -18,8 +18,8 @@ const x: B = { c: B }; //// [a.js] -// This test is just like exportEqualsProperty2, but with `export default`. "use strict"; +// This test is just like exportEqualsProperty2, but with `export default`. exports.__esModule = true; var C = (function () { function C() { diff --git a/tests/baselines/reference/exportEqualCallable.js b/tests/baselines/reference/exportEqualCallable.js index 177e3943ac717..830af3a2a3656 100644 --- a/tests/baselines/reference/exportEqualCallable.js +++ b/tests/baselines/reference/exportEqualCallable.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportEqualCallable.ts] //// //// [exportEqualCallable_0.ts] - var server: { (): any; }; diff --git a/tests/baselines/reference/exportEqualCallable.symbols b/tests/baselines/reference/exportEqualCallable.symbols index df1c6da8c7b7a..38c9b8f66e0e6 100644 --- a/tests/baselines/reference/exportEqualCallable.symbols +++ b/tests/baselines/reference/exportEqualCallable.symbols @@ -7,12 +7,11 @@ connect(); >connect : Symbol(connect, Decl(exportEqualCallable_1.ts, 0, 0)) === tests/cases/compiler/exportEqualCallable_0.ts === - var server: { ->server : Symbol(server, Decl(exportEqualCallable_0.ts, 1, 3)) +>server : Symbol(server, Decl(exportEqualCallable_0.ts, 0, 3)) (): any; }; export = server; ->server : Symbol(server, Decl(exportEqualCallable_0.ts, 1, 3)) +>server : Symbol(server, Decl(exportEqualCallable_0.ts, 0, 3)) diff --git a/tests/baselines/reference/exportEqualCallable.types b/tests/baselines/reference/exportEqualCallable.types index 0a0845231372d..6ea74aa84bf35 100644 --- a/tests/baselines/reference/exportEqualCallable.types +++ b/tests/baselines/reference/exportEqualCallable.types @@ -8,7 +8,6 @@ connect(); >connect : () => any === tests/cases/compiler/exportEqualCallable_0.ts === - var server: { >server : () => any diff --git a/tests/baselines/reference/exportEqualsDefaultProperty.js b/tests/baselines/reference/exportEqualsDefaultProperty.js index 9cf7a7b2ee8a3..3e7fc4d12afc4 100644 --- a/tests/baselines/reference/exportEqualsDefaultProperty.js +++ b/tests/baselines/reference/exportEqualsDefaultProperty.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportEqualsDefaultProperty.ts] //// //// [exp.ts] - var x = { "greeting": "hello, world", "default": 42 diff --git a/tests/baselines/reference/exportEqualsDefaultProperty.symbols b/tests/baselines/reference/exportEqualsDefaultProperty.symbols index 54bbbde69564a..99f4cb2253029 100644 --- a/tests/baselines/reference/exportEqualsDefaultProperty.symbols +++ b/tests/baselines/reference/exportEqualsDefaultProperty.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/exp.ts === - var x = { ->x : Symbol(x, Decl(exp.ts, 1, 3)) +>x : Symbol(x, Decl(exp.ts, 0, 3)) "greeting": "hello, world", "default": 42 }; export = x ->x : Symbol(x, Decl(exp.ts, 1, 3)) +>x : Symbol(x, Decl(exp.ts, 0, 3)) === tests/cases/compiler/imp.ts === import foo from "./exp"; diff --git a/tests/baselines/reference/exportEqualsDefaultProperty.types b/tests/baselines/reference/exportEqualsDefaultProperty.types index b6e3be008a1c8..57fe40a833a95 100644 --- a/tests/baselines/reference/exportEqualsDefaultProperty.types +++ b/tests/baselines/reference/exportEqualsDefaultProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/exp.ts === - var x = { >x : { "greeting": string; "default": number; } >{ "greeting": "hello, world", "default": 42} : { "greeting": string; "default": number; } diff --git a/tests/baselines/reference/exportEqualsProperty2.js b/tests/baselines/reference/exportEqualsProperty2.js index 36fcbdf34469f..5cfcab3e774bb 100644 --- a/tests/baselines/reference/exportEqualsProperty2.js +++ b/tests/baselines/reference/exportEqualsProperty2.js @@ -18,8 +18,8 @@ const x: B = { c: B }; //// [a.js] -// This test is just like exportDefaultProperty2, but with `export =`. "use strict"; +// This test is just like exportDefaultProperty2, but with `export =`. var C = (function () { function C() { } diff --git a/tests/baselines/reference/exportImport.errors.txt b/tests/baselines/reference/exportImport.errors.txt index fb5a41fe1ebec..4f397d54a557d 100644 --- a/tests/baselines/reference/exportImport.errors.txt +++ b/tests/baselines/reference/exportImport.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/w1.ts(2,1): error TS2449: Class 'Widget1' used before its declaration. -tests/cases/compiler/w1.ts(2,10): error TS2449: Class 'Widget1' used before its declaration. +tests/cases/compiler/w1.ts(1,1): error TS2449: Class 'Widget1' used before its declaration. +tests/cases/compiler/w1.ts(1,10): error TS2449: Class 'Widget1' used before its declaration. ==== tests/cases/compiler/consumer.ts (0 errors) ==== @@ -9,7 +9,6 @@ tests/cases/compiler/w1.ts(2,10): error TS2449: Class 'Widget1' used before its return new e.w(); } ==== tests/cases/compiler/w1.ts (2 errors) ==== - export = Widget1 ~~~~~~~~~~~~~~~~ !!! error TS2449: Class 'Widget1' used before its declaration. diff --git a/tests/baselines/reference/exportImport.js b/tests/baselines/reference/exportImport.js index 615f3d266abb0..031dc8974ed46 100644 --- a/tests/baselines/reference/exportImport.js +++ b/tests/baselines/reference/exportImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportImport.ts] //// //// [w1.ts] - export = Widget1 class Widget1 { name = 'one'; } diff --git a/tests/baselines/reference/exportImport.symbols b/tests/baselines/reference/exportImport.symbols index 9f76955b9e6eb..415776d6c55d2 100644 --- a/tests/baselines/reference/exportImport.symbols +++ b/tests/baselines/reference/exportImport.symbols @@ -13,13 +13,12 @@ export function w(): e.w { // Should be OK >w : Symbol(e.w, Decl(exporter.ts, 0, 0)) } === tests/cases/compiler/w1.ts === - export = Widget1 ->Widget1 : Symbol(Widget1, Decl(w1.ts, 1, 16)) +>Widget1 : Symbol(Widget1, Decl(w1.ts, 0, 16)) class Widget1 { name = 'one'; } ->Widget1 : Symbol(Widget1, Decl(w1.ts, 1, 16)) ->name : Symbol(Widget1.name, Decl(w1.ts, 2, 15)) +>Widget1 : Symbol(Widget1, Decl(w1.ts, 0, 16)) +>name : Symbol(Widget1.name, Decl(w1.ts, 1, 15)) === tests/cases/compiler/exporter.ts === export import w = require('./w1'); diff --git a/tests/baselines/reference/exportImport.types b/tests/baselines/reference/exportImport.types index decfe97a594da..f06204bef687b 100644 --- a/tests/baselines/reference/exportImport.types +++ b/tests/baselines/reference/exportImport.types @@ -14,7 +14,6 @@ export function w(): e.w { // Should be OK >w : typeof e.w } === tests/cases/compiler/w1.ts === - export = Widget1 >Widget1 : Widget1 diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule2.js b/tests/baselines/reference/exportImportNonInstantiatedModule2.js index 1394d7492dda1..a1217fa485b5e 100644 --- a/tests/baselines/reference/exportImportNonInstantiatedModule2.js +++ b/tests/baselines/reference/exportImportNonInstantiatedModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportImportNonInstantiatedModule2.ts] //// //// [w1.ts] - export = Widget1 interface Widget1 { name: string; } diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols b/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols index 148fd03b8289a..67d05bf4cea9d 100644 --- a/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols +++ b/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols @@ -11,13 +11,12 @@ export function w(): e.w { // Should be OK >name : Symbol(name, Decl(consumer.ts, 3, 12)) } === tests/cases/compiler/w1.ts === - export = Widget1 ->Widget1 : Symbol(Widget1, Decl(w1.ts, 1, 16)) +>Widget1 : Symbol(Widget1, Decl(w1.ts, 0, 16)) interface Widget1 { name: string; } ->Widget1 : Symbol(Widget1, Decl(w1.ts, 1, 16)) ->name : Symbol(Widget1.name, Decl(w1.ts, 2, 19)) +>Widget1 : Symbol(Widget1, Decl(w1.ts, 0, 16)) +>name : Symbol(Widget1.name, Decl(w1.ts, 1, 19)) === tests/cases/compiler/exporter.ts === export import w = require('./w1'); diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule2.types b/tests/baselines/reference/exportImportNonInstantiatedModule2.types index 01016fcc4eced..9c01926526fde 100644 --- a/tests/baselines/reference/exportImportNonInstantiatedModule2.types +++ b/tests/baselines/reference/exportImportNonInstantiatedModule2.types @@ -13,7 +13,6 @@ export function w(): e.w { // Should be OK >'value' : "value" } === tests/cases/compiler/w1.ts === - export = Widget1 >Widget1 : Widget1 diff --git a/tests/baselines/reference/exportNonInitializedVariablesAMD.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesAMD.errors.txt index 28d7253a70c0c..d62adf754d614 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesAMD.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesAMD.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesAMD.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesAMD.js b/tests/baselines/reference/exportNonInitializedVariablesAMD.js index f7ee0b8d4d890..62b0e45e3a9c4 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesAMD.js +++ b/tests/baselines/reference/exportNonInitializedVariablesAMD.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesAMD.ts] - var; let; const; diff --git a/tests/baselines/reference/exportNonInitializedVariablesCommonJS.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesCommonJS.errors.txt index 84d4cab9c8353..8dc319b6babbe 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesCommonJS.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesCommonJS.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesCommonJS.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesCommonJS.js b/tests/baselines/reference/exportNonInitializedVariablesCommonJS.js index 7623127aee8f3..362798c15160c 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesCommonJS.js +++ b/tests/baselines/reference/exportNonInitializedVariablesCommonJS.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesCommonJS.ts] - var; let; const; diff --git a/tests/baselines/reference/exportNonInitializedVariablesES6.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesES6.errors.txt index 08e1d9588b644..84f9bcb59a473 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesES6.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesES6.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesES6.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesES6.js b/tests/baselines/reference/exportNonInitializedVariablesES6.js index e4f47b2dc683f..20093a5edeb65 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesES6.js +++ b/tests/baselines/reference/exportNonInitializedVariablesES6.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesES6.ts] - var; let; const; diff --git a/tests/baselines/reference/exportNonInitializedVariablesSystem.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesSystem.errors.txt index 1e461ea725346..cce77c1db430a 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesSystem.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesSystem.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesSystem.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesSystem.js b/tests/baselines/reference/exportNonInitializedVariablesSystem.js index 6c44da04802f4..e54719558cd8a 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesSystem.js +++ b/tests/baselines/reference/exportNonInitializedVariablesSystem.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesSystem.ts] - var; let; const; diff --git a/tests/baselines/reference/exportNonInitializedVariablesUMD.errors.txt b/tests/baselines/reference/exportNonInitializedVariablesUMD.errors.txt index b180c13850133..9e9c493c7d20c 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesUMD.errors.txt +++ b/tests/baselines/reference/exportNonInitializedVariablesUMD.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(2,4): error TS1123: Variable declaration list cannot be empty. -tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(3,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(3,1): error TS2304: Cannot find name 'let'. -tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(4,6): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(1,4): error TS1123: Variable declaration list cannot be empty. +tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(2,1): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(2,1): error TS2304: Cannot find name 'let'. +tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts(3,6): error TS1123: Variable declaration list cannot be empty. ==== tests/cases/conformance/externalModules/exportNonInitializedVariablesUMD.ts (4 errors) ==== - var; !!! error TS1123: Variable declaration list cannot be empty. diff --git a/tests/baselines/reference/exportNonInitializedVariablesUMD.js b/tests/baselines/reference/exportNonInitializedVariablesUMD.js index 504c6e700841c..cd6ef353fe3d0 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesUMD.js +++ b/tests/baselines/reference/exportNonInitializedVariablesUMD.js @@ -1,5 +1,4 @@ //// [exportNonInitializedVariablesUMD.ts] - var; let; const; diff --git a/tests/baselines/reference/exportSpecifierForAGlobal.errors.txt b/tests/baselines/reference/exportSpecifierForAGlobal.errors.txt index 559b9d5fbfe9c..d2f103a91fa27 100644 --- a/tests/baselines/reference/exportSpecifierForAGlobal.errors.txt +++ b/tests/baselines/reference/exportSpecifierForAGlobal.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/b.ts(1,9): error TS2661: Cannot export 'X'. Only local decl ==== tests/cases/compiler/a.d.ts (0 errors) ==== - declare class X { } ==== tests/cases/compiler/b.ts (1 errors) ==== diff --git a/tests/baselines/reference/exportSpecifierForAGlobal.js b/tests/baselines/reference/exportSpecifierForAGlobal.js index fe59f5071f2b8..6023b7c7f14b2 100644 --- a/tests/baselines/reference/exportSpecifierForAGlobal.js +++ b/tests/baselines/reference/exportSpecifierForAGlobal.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportSpecifierForAGlobal.ts] //// //// [a.d.ts] - declare class X { } //// [b.ts] diff --git a/tests/baselines/reference/exportStar-amd.errors.txt b/tests/baselines/reference/exportStar-amd.errors.txt index edd5c0d51bda4..a667c90224e93 100644 --- a/tests/baselines/reference/exportStar-amd.errors.txt +++ b/tests/baselines/reference/exportStar-amd.errors.txt @@ -4,7 +4,6 @@ tests/cases/conformance/es6/modules/t4.ts(3,1): error TS2308: Module "./t1" has ==== tests/cases/conformance/es6/modules/t1.ts (0 errors) ==== - export var x = 1; export var y = 2; diff --git a/tests/baselines/reference/exportStar-amd.js b/tests/baselines/reference/exportStar-amd.js index f25a68a5aa625..7658c470e5574 100644 --- a/tests/baselines/reference/exportStar-amd.js +++ b/tests/baselines/reference/exportStar-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportStar-amd.ts] //// //// [t1.ts] - export var x = 1; export var y = 2; diff --git a/tests/baselines/reference/exportStar.errors.txt b/tests/baselines/reference/exportStar.errors.txt index edd5c0d51bda4..a667c90224e93 100644 --- a/tests/baselines/reference/exportStar.errors.txt +++ b/tests/baselines/reference/exportStar.errors.txt @@ -4,7 +4,6 @@ tests/cases/conformance/es6/modules/t4.ts(3,1): error TS2308: Module "./t1" has ==== tests/cases/conformance/es6/modules/t1.ts (0 errors) ==== - export var x = 1; export var y = 2; diff --git a/tests/baselines/reference/exportStar.js b/tests/baselines/reference/exportStar.js index a188cefd8b6ce..36818f8ae9b76 100644 --- a/tests/baselines/reference/exportStar.js +++ b/tests/baselines/reference/exportStar.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportStar.ts] //// //// [t1.ts] - export var x = 1; export var y = 2; diff --git a/tests/baselines/reference/exportStarForValues.js b/tests/baselines/reference/exportStarForValues.js index 8376ec1927e93..dd8b9c7b4d4d2 100644 --- a/tests/baselines/reference/exportStarForValues.js +++ b/tests/baselines/reference/exportStarForValues.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues.symbols b/tests/baselines/reference/exportStarForValues.symbols index 343c7b23a141d..44db8692ac8c9 100644 --- a/tests/baselines/reference/exportStarForValues.symbols +++ b/tests/baselines/reference/exportStarForValues.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues.types b/tests/baselines/reference/exportStarForValues.types index b326a7e7ff617..e0285bc614ef3 100644 --- a/tests/baselines/reference/exportStarForValues.types +++ b/tests/baselines/reference/exportStarForValues.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues10.js b/tests/baselines/reference/exportStarForValues10.js index f7dd6e94ce5a1..e4314c4f7fdde 100644 --- a/tests/baselines/reference/exportStarForValues10.js +++ b/tests/baselines/reference/exportStarForValues10.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues10.ts] //// //// [file0.ts] - export var v = 1; //// [file1.ts] diff --git a/tests/baselines/reference/exportStarForValues10.symbols b/tests/baselines/reference/exportStarForValues10.symbols index d1dc20f91403f..96cd95e14bb8e 100644 --- a/tests/baselines/reference/exportStarForValues10.symbols +++ b/tests/baselines/reference/exportStarForValues10.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/file0.ts === - export var v = 1; ->v : Symbol(v, Decl(file0.ts, 1, 10)) +>v : Symbol(v, Decl(file0.ts, 0, 10)) === tests/cases/compiler/file1.ts === export interface Foo { x } diff --git a/tests/baselines/reference/exportStarForValues10.types b/tests/baselines/reference/exportStarForValues10.types index 2be6b0c7bfe6f..3d613a6e6d8e3 100644 --- a/tests/baselines/reference/exportStarForValues10.types +++ b/tests/baselines/reference/exportStarForValues10.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file0.ts === - export var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportStarForValues2.js b/tests/baselines/reference/exportStarForValues2.js index f18f9f1c587f1..f10ae1b9936fa 100644 --- a/tests/baselines/reference/exportStarForValues2.js +++ b/tests/baselines/reference/exportStarForValues2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues2.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues2.symbols b/tests/baselines/reference/exportStarForValues2.symbols index fe5529b0f6d79..007f15147c8b8 100644 --- a/tests/baselines/reference/exportStarForValues2.symbols +++ b/tests/baselines/reference/exportStarForValues2.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues2.types b/tests/baselines/reference/exportStarForValues2.types index 3a92d860ef8a3..56c997d6c6b1f 100644 --- a/tests/baselines/reference/exportStarForValues2.types +++ b/tests/baselines/reference/exportStarForValues2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues3.js b/tests/baselines/reference/exportStarForValues3.js index 5ccd12f8a37e0..83a818a3e81de 100644 --- a/tests/baselines/reference/exportStarForValues3.js +++ b/tests/baselines/reference/exportStarForValues3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues3.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues3.symbols b/tests/baselines/reference/exportStarForValues3.symbols index 5a9cc5f8d5296..e83f291ced6e0 100644 --- a/tests/baselines/reference/exportStarForValues3.symbols +++ b/tests/baselines/reference/exportStarForValues3.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export interface A { x } diff --git a/tests/baselines/reference/exportStarForValues3.types b/tests/baselines/reference/exportStarForValues3.types index 90d38d867036a..928139e45d003 100644 --- a/tests/baselines/reference/exportStarForValues3.types +++ b/tests/baselines/reference/exportStarForValues3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues4.js b/tests/baselines/reference/exportStarForValues4.js index e06b5e26207de..0a49e982e29ec 100644 --- a/tests/baselines/reference/exportStarForValues4.js +++ b/tests/baselines/reference/exportStarForValues4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues4.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues4.symbols b/tests/baselines/reference/exportStarForValues4.symbols index a6812b729520b..08b93627478fd 100644 --- a/tests/baselines/reference/exportStarForValues4.symbols +++ b/tests/baselines/reference/exportStarForValues4.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export interface A { x } diff --git a/tests/baselines/reference/exportStarForValues4.types b/tests/baselines/reference/exportStarForValues4.types index b00dd126a9cb7..264603307292e 100644 --- a/tests/baselines/reference/exportStarForValues4.types +++ b/tests/baselines/reference/exportStarForValues4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues5.js b/tests/baselines/reference/exportStarForValues5.js index 37c8d59c91a89..812058ebd06f3 100644 --- a/tests/baselines/reference/exportStarForValues5.js +++ b/tests/baselines/reference/exportStarForValues5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues5.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues5.symbols b/tests/baselines/reference/exportStarForValues5.symbols index 06e6a859e239c..907b8e7dacf2e 100644 --- a/tests/baselines/reference/exportStarForValues5.symbols +++ b/tests/baselines/reference/exportStarForValues5.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues5.types b/tests/baselines/reference/exportStarForValues5.types index 9edfc88289a86..148457fd8dba2 100644 --- a/tests/baselines/reference/exportStarForValues5.types +++ b/tests/baselines/reference/exportStarForValues5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues6.js b/tests/baselines/reference/exportStarForValues6.js index dd17fbcddb21c..15c2324d205d7 100644 --- a/tests/baselines/reference/exportStarForValues6.js +++ b/tests/baselines/reference/exportStarForValues6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues6.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues6.symbols b/tests/baselines/reference/exportStarForValues6.symbols index 1eba5698be5d4..4a8fe67e9279c 100644 --- a/tests/baselines/reference/exportStarForValues6.symbols +++ b/tests/baselines/reference/exportStarForValues6.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues6.types b/tests/baselines/reference/exportStarForValues6.types index 3d418e2dc2468..eb76ce2ca5aa2 100644 --- a/tests/baselines/reference/exportStarForValues6.types +++ b/tests/baselines/reference/exportStarForValues6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues7.js b/tests/baselines/reference/exportStarForValues7.js index 1f5163dd9cd36..af213d1308028 100644 --- a/tests/baselines/reference/exportStarForValues7.js +++ b/tests/baselines/reference/exportStarForValues7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues7.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues7.symbols b/tests/baselines/reference/exportStarForValues7.symbols index 952b7e3eff585..dfbea67d4d965 100644 --- a/tests/baselines/reference/exportStarForValues7.symbols +++ b/tests/baselines/reference/exportStarForValues7.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValues7.types b/tests/baselines/reference/exportStarForValues7.types index 41927bab512e8..83c454faa0666 100644 --- a/tests/baselines/reference/exportStarForValues7.types +++ b/tests/baselines/reference/exportStarForValues7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues8.js b/tests/baselines/reference/exportStarForValues8.js index 6f52bce89f97f..7a0045c22cb23 100644 --- a/tests/baselines/reference/exportStarForValues8.js +++ b/tests/baselines/reference/exportStarForValues8.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues8.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues8.symbols b/tests/baselines/reference/exportStarForValues8.symbols index 3b893dfa42b03..eee82bf354564 100644 --- a/tests/baselines/reference/exportStarForValues8.symbols +++ b/tests/baselines/reference/exportStarForValues8.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export interface A { x } diff --git a/tests/baselines/reference/exportStarForValues8.types b/tests/baselines/reference/exportStarForValues8.types index 7d06bd0d1f53b..b4fab22443602 100644 --- a/tests/baselines/reference/exportStarForValues8.types +++ b/tests/baselines/reference/exportStarForValues8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValues9.js b/tests/baselines/reference/exportStarForValues9.js index 3c34bb1afdb71..8eb92c05e741f 100644 --- a/tests/baselines/reference/exportStarForValues9.js +++ b/tests/baselines/reference/exportStarForValues9.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValues9.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValues9.symbols b/tests/baselines/reference/exportStarForValues9.symbols index e311f661a00b0..0889ad876eea4 100644 --- a/tests/baselines/reference/exportStarForValues9.symbols +++ b/tests/baselines/reference/exportStarForValues9.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export interface A { x } diff --git a/tests/baselines/reference/exportStarForValues9.types b/tests/baselines/reference/exportStarForValues9.types index aa09e1f12cfb7..843f0a42584c4 100644 --- a/tests/baselines/reference/exportStarForValues9.types +++ b/tests/baselines/reference/exportStarForValues9.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarForValuesInSystem.js b/tests/baselines/reference/exportStarForValuesInSystem.js index 4fbd3ca0066cd..8cd960111991f 100644 --- a/tests/baselines/reference/exportStarForValuesInSystem.js +++ b/tests/baselines/reference/exportStarForValuesInSystem.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarForValuesInSystem.ts] //// //// [file1.ts] - export interface Foo { x } //// [file2.ts] diff --git a/tests/baselines/reference/exportStarForValuesInSystem.symbols b/tests/baselines/reference/exportStarForValuesInSystem.symbols index d4ffe0eeaa2ee..c2367441a7303 100644 --- a/tests/baselines/reference/exportStarForValuesInSystem.symbols +++ b/tests/baselines/reference/exportStarForValuesInSystem.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Symbol(Foo, Decl(file1.ts, 0, 0)) ->x : Symbol(Foo.x, Decl(file1.ts, 1, 22)) +>x : Symbol(Foo.x, Decl(file1.ts, 0, 22)) === tests/cases/compiler/file2.ts === export * from "file1" diff --git a/tests/baselines/reference/exportStarForValuesInSystem.types b/tests/baselines/reference/exportStarForValuesInSystem.types index bbb9a5a6b15f5..b914f93a98f95 100644 --- a/tests/baselines/reference/exportStarForValuesInSystem.types +++ b/tests/baselines/reference/exportStarForValuesInSystem.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export interface Foo { x } >Foo : Foo >x : any diff --git a/tests/baselines/reference/exportStarFromEmptyModule.errors.txt b/tests/baselines/reference/exportStarFromEmptyModule.errors.txt index 8ca80fae40870..6c5e4b58d36c7 100644 --- a/tests/baselines/reference/exportStarFromEmptyModule.errors.txt +++ b/tests/baselines/reference/exportStarFromEmptyModule.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/exportStarFromEmptyModule_module4.ts(4,5): error TS2339: Pr ==== tests/cases/compiler/exportStarFromEmptyModule_module1.ts (0 errors) ==== - export class A { static r; } diff --git a/tests/baselines/reference/exportStarFromEmptyModule.js b/tests/baselines/reference/exportStarFromEmptyModule.js index 4fcac9312b987..ce282722a298b 100644 --- a/tests/baselines/reference/exportStarFromEmptyModule.js +++ b/tests/baselines/reference/exportStarFromEmptyModule.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/exportStarFromEmptyModule.ts] //// //// [exportStarFromEmptyModule_module1.ts] - export class A { static r; } diff --git a/tests/baselines/reference/exportsAndImports1-amd.js b/tests/baselines/reference/exportsAndImports1-amd.js index 87761c779faab..16c4a86a7c16d 100644 --- a/tests/baselines/reference/exportsAndImports1-amd.js +++ b/tests/baselines/reference/exportsAndImports1-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports1-amd.ts] //// //// [t1.ts] - var v = 1; function f() { } class C { diff --git a/tests/baselines/reference/exportsAndImports1-amd.symbols b/tests/baselines/reference/exportsAndImports1-amd.symbols index dc90c8c7bf938..64db869f45daa 100644 --- a/tests/baselines/reference/exportsAndImports1-amd.symbols +++ b/tests/baselines/reference/exportsAndImports1-amd.symbols @@ -1,65 +1,64 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 3)) +>v : Symbol(v, Decl(t1.ts, 0, 3)) function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 10)) +>f : Symbol(f, Decl(t1.ts, 0, 10)) class C { ->C : Symbol(C, Decl(t1.ts, 2, 16)) +>C : Symbol(C, Decl(t1.ts, 1, 16)) } interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 8)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 8)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 14)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 14)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 10)) +>I : Symbol(I, Decl(t1.ts, 15, 10)) } } type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 16)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 16)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v, f, C, I, E, D, M, N, T, a }; ->v : Symbol(v, Decl(t1.ts, 23, 8)) ->f : Symbol(f, Decl(t1.ts, 23, 11)) ->C : Symbol(C, Decl(t1.ts, 23, 14)) ->I : Symbol(I, Decl(t1.ts, 23, 17)) ->E : Symbol(E, Decl(t1.ts, 23, 20)) ->D : Symbol(D, Decl(t1.ts, 23, 23)) ->M : Symbol(M, Decl(t1.ts, 23, 26)) ->N : Symbol(N, Decl(t1.ts, 23, 29)) ->T : Symbol(T, Decl(t1.ts, 23, 32)) ->a : Symbol(a, Decl(t1.ts, 23, 35)) +>v : Symbol(v, Decl(t1.ts, 22, 8)) +>f : Symbol(f, Decl(t1.ts, 22, 11)) +>C : Symbol(C, Decl(t1.ts, 22, 14)) +>I : Symbol(I, Decl(t1.ts, 22, 17)) +>E : Symbol(E, Decl(t1.ts, 22, 20)) +>D : Symbol(D, Decl(t1.ts, 22, 23)) +>M : Symbol(M, Decl(t1.ts, 22, 26)) +>N : Symbol(N, Decl(t1.ts, 22, 29)) +>T : Symbol(T, Decl(t1.ts, 22, 32)) +>a : Symbol(a, Decl(t1.ts, 22, 35)) === tests/cases/conformance/es6/modules/t2.ts === export { v, f, C, I, E, D, M, N, T, a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports1-amd.types b/tests/baselines/reference/exportsAndImports1-amd.types index 05c8b6d7af5fb..3a8763fb5782f 100644 --- a/tests/baselines/reference/exportsAndImports1-amd.types +++ b/tests/baselines/reference/exportsAndImports1-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports1-es6.js b/tests/baselines/reference/exportsAndImports1-es6.js index 6b9a40f0ea217..71e8de6f9faa0 100644 --- a/tests/baselines/reference/exportsAndImports1-es6.js +++ b/tests/baselines/reference/exportsAndImports1-es6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts] //// //// [t1.ts] - var v = 1; function f() { } class C { diff --git a/tests/baselines/reference/exportsAndImports1-es6.symbols b/tests/baselines/reference/exportsAndImports1-es6.symbols index dc90c8c7bf938..64db869f45daa 100644 --- a/tests/baselines/reference/exportsAndImports1-es6.symbols +++ b/tests/baselines/reference/exportsAndImports1-es6.symbols @@ -1,65 +1,64 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 3)) +>v : Symbol(v, Decl(t1.ts, 0, 3)) function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 10)) +>f : Symbol(f, Decl(t1.ts, 0, 10)) class C { ->C : Symbol(C, Decl(t1.ts, 2, 16)) +>C : Symbol(C, Decl(t1.ts, 1, 16)) } interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 8)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 8)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 14)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 14)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 10)) +>I : Symbol(I, Decl(t1.ts, 15, 10)) } } type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 16)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 16)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v, f, C, I, E, D, M, N, T, a }; ->v : Symbol(v, Decl(t1.ts, 23, 8)) ->f : Symbol(f, Decl(t1.ts, 23, 11)) ->C : Symbol(C, Decl(t1.ts, 23, 14)) ->I : Symbol(I, Decl(t1.ts, 23, 17)) ->E : Symbol(E, Decl(t1.ts, 23, 20)) ->D : Symbol(D, Decl(t1.ts, 23, 23)) ->M : Symbol(M, Decl(t1.ts, 23, 26)) ->N : Symbol(N, Decl(t1.ts, 23, 29)) ->T : Symbol(T, Decl(t1.ts, 23, 32)) ->a : Symbol(a, Decl(t1.ts, 23, 35)) +>v : Symbol(v, Decl(t1.ts, 22, 8)) +>f : Symbol(f, Decl(t1.ts, 22, 11)) +>C : Symbol(C, Decl(t1.ts, 22, 14)) +>I : Symbol(I, Decl(t1.ts, 22, 17)) +>E : Symbol(E, Decl(t1.ts, 22, 20)) +>D : Symbol(D, Decl(t1.ts, 22, 23)) +>M : Symbol(M, Decl(t1.ts, 22, 26)) +>N : Symbol(N, Decl(t1.ts, 22, 29)) +>T : Symbol(T, Decl(t1.ts, 22, 32)) +>a : Symbol(a, Decl(t1.ts, 22, 35)) === tests/cases/conformance/es6/modules/t2.ts === export { v, f, C, I, E, D, M, N, T, a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports1-es6.types b/tests/baselines/reference/exportsAndImports1-es6.types index 05c8b6d7af5fb..3a8763fb5782f 100644 --- a/tests/baselines/reference/exportsAndImports1-es6.types +++ b/tests/baselines/reference/exportsAndImports1-es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports1.js b/tests/baselines/reference/exportsAndImports1.js index 56f74d27473c4..30fef6e7ccfdf 100644 --- a/tests/baselines/reference/exportsAndImports1.js +++ b/tests/baselines/reference/exportsAndImports1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports1.ts] //// //// [t1.ts] - var v = 1; function f() { } class C { diff --git a/tests/baselines/reference/exportsAndImports1.symbols b/tests/baselines/reference/exportsAndImports1.symbols index dc90c8c7bf938..64db869f45daa 100644 --- a/tests/baselines/reference/exportsAndImports1.symbols +++ b/tests/baselines/reference/exportsAndImports1.symbols @@ -1,65 +1,64 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 3)) +>v : Symbol(v, Decl(t1.ts, 0, 3)) function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 10)) +>f : Symbol(f, Decl(t1.ts, 0, 10)) class C { ->C : Symbol(C, Decl(t1.ts, 2, 16)) +>C : Symbol(C, Decl(t1.ts, 1, 16)) } interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 8)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 8)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 14)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 14)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 10)) +>I : Symbol(I, Decl(t1.ts, 15, 10)) } } type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 16)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 16)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v, f, C, I, E, D, M, N, T, a }; ->v : Symbol(v, Decl(t1.ts, 23, 8)) ->f : Symbol(f, Decl(t1.ts, 23, 11)) ->C : Symbol(C, Decl(t1.ts, 23, 14)) ->I : Symbol(I, Decl(t1.ts, 23, 17)) ->E : Symbol(E, Decl(t1.ts, 23, 20)) ->D : Symbol(D, Decl(t1.ts, 23, 23)) ->M : Symbol(M, Decl(t1.ts, 23, 26)) ->N : Symbol(N, Decl(t1.ts, 23, 29)) ->T : Symbol(T, Decl(t1.ts, 23, 32)) ->a : Symbol(a, Decl(t1.ts, 23, 35)) +>v : Symbol(v, Decl(t1.ts, 22, 8)) +>f : Symbol(f, Decl(t1.ts, 22, 11)) +>C : Symbol(C, Decl(t1.ts, 22, 14)) +>I : Symbol(I, Decl(t1.ts, 22, 17)) +>E : Symbol(E, Decl(t1.ts, 22, 20)) +>D : Symbol(D, Decl(t1.ts, 22, 23)) +>M : Symbol(M, Decl(t1.ts, 22, 26)) +>N : Symbol(N, Decl(t1.ts, 22, 29)) +>T : Symbol(T, Decl(t1.ts, 22, 32)) +>a : Symbol(a, Decl(t1.ts, 22, 35)) === tests/cases/conformance/es6/modules/t2.ts === export { v, f, C, I, E, D, M, N, T, a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports1.types b/tests/baselines/reference/exportsAndImports1.types index 05c8b6d7af5fb..3a8763fb5782f 100644 --- a/tests/baselines/reference/exportsAndImports1.types +++ b/tests/baselines/reference/exportsAndImports1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports2-amd.js b/tests/baselines/reference/exportsAndImports2-amd.js index 5154751b21e12..04685dcaa332a 100644 --- a/tests/baselines/reference/exportsAndImports2-amd.js +++ b/tests/baselines/reference/exportsAndImports2-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports2-amd.ts] //// //// [t1.ts] - export var x = "x"; export var y = "y"; diff --git a/tests/baselines/reference/exportsAndImports2-amd.symbols b/tests/baselines/reference/exportsAndImports2-amd.symbols index 8b53794abae47..293755a80051b 100644 --- a/tests/baselines/reference/exportsAndImports2-amd.symbols +++ b/tests/baselines/reference/exportsAndImports2-amd.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; ->x : Symbol(x, Decl(t1.ts, 1, 10)) +>x : Symbol(x, Decl(t1.ts, 0, 10)) export var y = "y"; ->y : Symbol(y, Decl(t1.ts, 2, 10)) +>y : Symbol(y, Decl(t1.ts, 1, 10)) === tests/cases/conformance/es6/modules/t2.ts === export { x as y, y as x } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports2-amd.types b/tests/baselines/reference/exportsAndImports2-amd.types index 46e42174a7710..0f5614794e300 100644 --- a/tests/baselines/reference/exportsAndImports2-amd.types +++ b/tests/baselines/reference/exportsAndImports2-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; >x : string >"x" : "x" diff --git a/tests/baselines/reference/exportsAndImports2-es6.js b/tests/baselines/reference/exportsAndImports2-es6.js index b0714b83c39e6..2a57a43f1a5ff 100644 --- a/tests/baselines/reference/exportsAndImports2-es6.js +++ b/tests/baselines/reference/exportsAndImports2-es6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts] //// //// [t1.ts] - export var x = "x"; export var y = "y"; diff --git a/tests/baselines/reference/exportsAndImports2-es6.symbols b/tests/baselines/reference/exportsAndImports2-es6.symbols index 8b53794abae47..293755a80051b 100644 --- a/tests/baselines/reference/exportsAndImports2-es6.symbols +++ b/tests/baselines/reference/exportsAndImports2-es6.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; ->x : Symbol(x, Decl(t1.ts, 1, 10)) +>x : Symbol(x, Decl(t1.ts, 0, 10)) export var y = "y"; ->y : Symbol(y, Decl(t1.ts, 2, 10)) +>y : Symbol(y, Decl(t1.ts, 1, 10)) === tests/cases/conformance/es6/modules/t2.ts === export { x as y, y as x } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports2-es6.types b/tests/baselines/reference/exportsAndImports2-es6.types index 46e42174a7710..0f5614794e300 100644 --- a/tests/baselines/reference/exportsAndImports2-es6.types +++ b/tests/baselines/reference/exportsAndImports2-es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; >x : string >"x" : "x" diff --git a/tests/baselines/reference/exportsAndImports2.js b/tests/baselines/reference/exportsAndImports2.js index 5b3fe689d9029..d905ab3827fc5 100644 --- a/tests/baselines/reference/exportsAndImports2.js +++ b/tests/baselines/reference/exportsAndImports2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports2.ts] //// //// [t1.ts] - export var x = "x"; export var y = "y"; diff --git a/tests/baselines/reference/exportsAndImports2.symbols b/tests/baselines/reference/exportsAndImports2.symbols index 8b53794abae47..293755a80051b 100644 --- a/tests/baselines/reference/exportsAndImports2.symbols +++ b/tests/baselines/reference/exportsAndImports2.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; ->x : Symbol(x, Decl(t1.ts, 1, 10)) +>x : Symbol(x, Decl(t1.ts, 0, 10)) export var y = "y"; ->y : Symbol(y, Decl(t1.ts, 2, 10)) +>y : Symbol(y, Decl(t1.ts, 1, 10)) === tests/cases/conformance/es6/modules/t2.ts === export { x as y, y as x } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports2.types b/tests/baselines/reference/exportsAndImports2.types index 46e42174a7710..0f5614794e300 100644 --- a/tests/baselines/reference/exportsAndImports2.types +++ b/tests/baselines/reference/exportsAndImports2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var x = "x"; >x : string >"x" : "x" diff --git a/tests/baselines/reference/exportsAndImports3-amd.js b/tests/baselines/reference/exportsAndImports3-amd.js index a6af4adb5f48b..87dc8d03ab818 100644 --- a/tests/baselines/reference/exportsAndImports3-amd.js +++ b/tests/baselines/reference/exportsAndImports3-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports3-amd.ts] //// //// [t1.ts] - export var v = 1; export function f() { } export class C { diff --git a/tests/baselines/reference/exportsAndImports3-amd.symbols b/tests/baselines/reference/exportsAndImports3-amd.symbols index a46d7df2a68a4..f71014281c2a6 100644 --- a/tests/baselines/reference/exportsAndImports3-amd.symbols +++ b/tests/baselines/reference/exportsAndImports3-amd.symbols @@ -1,75 +1,74 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 10)) +>v : Symbol(v, Decl(t1.ts, 0, 10)) export function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 17)) +>f : Symbol(f, Decl(t1.ts, 0, 17)) export class C { ->C : Symbol(C, Decl(t1.ts, 2, 23)) +>C : Symbol(C, Decl(t1.ts, 1, 23)) } export interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } export enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 15)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 15)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } export const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 21)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 21)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } export module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } export module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 17)) +>I : Symbol(I, Decl(t1.ts, 15, 17)) } } export type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) export import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 23)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 23)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 }; ->v : Symbol(v1, Decl(t1.ts, 23, 8)) ->v1 : Symbol(v1, Decl(t1.ts, 23, 8)) ->f : Symbol(f1, Decl(t1.ts, 23, 17)) ->f1 : Symbol(f1, Decl(t1.ts, 23, 17)) ->C : Symbol(C1, Decl(t1.ts, 23, 26)) ->C1 : Symbol(C1, Decl(t1.ts, 23, 26)) ->I : Symbol(I1, Decl(t1.ts, 23, 35)) ->I1 : Symbol(I1, Decl(t1.ts, 23, 35)) ->E : Symbol(E1, Decl(t1.ts, 23, 44)) ->E1 : Symbol(E1, Decl(t1.ts, 23, 44)) ->D : Symbol(D1, Decl(t1.ts, 23, 53)) ->D1 : Symbol(D1, Decl(t1.ts, 23, 53)) ->M : Symbol(M1, Decl(t1.ts, 23, 62)) ->M1 : Symbol(M1, Decl(t1.ts, 23, 62)) ->N : Symbol(N1, Decl(t1.ts, 23, 71)) ->N1 : Symbol(N1, Decl(t1.ts, 23, 71)) ->T : Symbol(T1, Decl(t1.ts, 23, 80)) ->T1 : Symbol(T1, Decl(t1.ts, 23, 80)) ->a : Symbol(a1, Decl(t1.ts, 23, 89)) ->a1 : Symbol(a1, Decl(t1.ts, 23, 89)) +>v : Symbol(v1, Decl(t1.ts, 22, 8)) +>v1 : Symbol(v1, Decl(t1.ts, 22, 8)) +>f : Symbol(f1, Decl(t1.ts, 22, 17)) +>f1 : Symbol(f1, Decl(t1.ts, 22, 17)) +>C : Symbol(C1, Decl(t1.ts, 22, 26)) +>C1 : Symbol(C1, Decl(t1.ts, 22, 26)) +>I : Symbol(I1, Decl(t1.ts, 22, 35)) +>I1 : Symbol(I1, Decl(t1.ts, 22, 35)) +>E : Symbol(E1, Decl(t1.ts, 22, 44)) +>E1 : Symbol(E1, Decl(t1.ts, 22, 44)) +>D : Symbol(D1, Decl(t1.ts, 22, 53)) +>D1 : Symbol(D1, Decl(t1.ts, 22, 53)) +>M : Symbol(M1, Decl(t1.ts, 22, 62)) +>M1 : Symbol(M1, Decl(t1.ts, 22, 62)) +>N : Symbol(N1, Decl(t1.ts, 22, 71)) +>N1 : Symbol(N1, Decl(t1.ts, 22, 71)) +>T : Symbol(T1, Decl(t1.ts, 22, 80)) +>T1 : Symbol(T1, Decl(t1.ts, 22, 80)) +>a : Symbol(a1, Decl(t1.ts, 22, 89)) +>a1 : Symbol(a1, Decl(t1.ts, 22, 89)) === tests/cases/conformance/es6/modules/t2.ts === export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports3-amd.types b/tests/baselines/reference/exportsAndImports3-amd.types index 5292f01af0de3..afb32cb9c541f 100644 --- a/tests/baselines/reference/exportsAndImports3-amd.types +++ b/tests/baselines/reference/exportsAndImports3-amd.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports3-es6.js b/tests/baselines/reference/exportsAndImports3-es6.js index 1ac23446807d2..541223717773e 100644 --- a/tests/baselines/reference/exportsAndImports3-es6.js +++ b/tests/baselines/reference/exportsAndImports3-es6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts] //// //// [t1.ts] - export var v = 1; export function f() { } export class C { diff --git a/tests/baselines/reference/exportsAndImports3-es6.symbols b/tests/baselines/reference/exportsAndImports3-es6.symbols index a46d7df2a68a4..f71014281c2a6 100644 --- a/tests/baselines/reference/exportsAndImports3-es6.symbols +++ b/tests/baselines/reference/exportsAndImports3-es6.symbols @@ -1,75 +1,74 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 10)) +>v : Symbol(v, Decl(t1.ts, 0, 10)) export function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 17)) +>f : Symbol(f, Decl(t1.ts, 0, 17)) export class C { ->C : Symbol(C, Decl(t1.ts, 2, 23)) +>C : Symbol(C, Decl(t1.ts, 1, 23)) } export interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } export enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 15)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 15)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } export const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 21)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 21)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } export module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } export module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 17)) +>I : Symbol(I, Decl(t1.ts, 15, 17)) } } export type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) export import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 23)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 23)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 }; ->v : Symbol(v1, Decl(t1.ts, 23, 8)) ->v1 : Symbol(v1, Decl(t1.ts, 23, 8)) ->f : Symbol(f1, Decl(t1.ts, 23, 17)) ->f1 : Symbol(f1, Decl(t1.ts, 23, 17)) ->C : Symbol(C1, Decl(t1.ts, 23, 26)) ->C1 : Symbol(C1, Decl(t1.ts, 23, 26)) ->I : Symbol(I1, Decl(t1.ts, 23, 35)) ->I1 : Symbol(I1, Decl(t1.ts, 23, 35)) ->E : Symbol(E1, Decl(t1.ts, 23, 44)) ->E1 : Symbol(E1, Decl(t1.ts, 23, 44)) ->D : Symbol(D1, Decl(t1.ts, 23, 53)) ->D1 : Symbol(D1, Decl(t1.ts, 23, 53)) ->M : Symbol(M1, Decl(t1.ts, 23, 62)) ->M1 : Symbol(M1, Decl(t1.ts, 23, 62)) ->N : Symbol(N1, Decl(t1.ts, 23, 71)) ->N1 : Symbol(N1, Decl(t1.ts, 23, 71)) ->T : Symbol(T1, Decl(t1.ts, 23, 80)) ->T1 : Symbol(T1, Decl(t1.ts, 23, 80)) ->a : Symbol(a1, Decl(t1.ts, 23, 89)) ->a1 : Symbol(a1, Decl(t1.ts, 23, 89)) +>v : Symbol(v1, Decl(t1.ts, 22, 8)) +>v1 : Symbol(v1, Decl(t1.ts, 22, 8)) +>f : Symbol(f1, Decl(t1.ts, 22, 17)) +>f1 : Symbol(f1, Decl(t1.ts, 22, 17)) +>C : Symbol(C1, Decl(t1.ts, 22, 26)) +>C1 : Symbol(C1, Decl(t1.ts, 22, 26)) +>I : Symbol(I1, Decl(t1.ts, 22, 35)) +>I1 : Symbol(I1, Decl(t1.ts, 22, 35)) +>E : Symbol(E1, Decl(t1.ts, 22, 44)) +>E1 : Symbol(E1, Decl(t1.ts, 22, 44)) +>D : Symbol(D1, Decl(t1.ts, 22, 53)) +>D1 : Symbol(D1, Decl(t1.ts, 22, 53)) +>M : Symbol(M1, Decl(t1.ts, 22, 62)) +>M1 : Symbol(M1, Decl(t1.ts, 22, 62)) +>N : Symbol(N1, Decl(t1.ts, 22, 71)) +>N1 : Symbol(N1, Decl(t1.ts, 22, 71)) +>T : Symbol(T1, Decl(t1.ts, 22, 80)) +>T1 : Symbol(T1, Decl(t1.ts, 22, 80)) +>a : Symbol(a1, Decl(t1.ts, 22, 89)) +>a1 : Symbol(a1, Decl(t1.ts, 22, 89)) === tests/cases/conformance/es6/modules/t2.ts === export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports3-es6.types b/tests/baselines/reference/exportsAndImports3-es6.types index 5292f01af0de3..afb32cb9c541f 100644 --- a/tests/baselines/reference/exportsAndImports3-es6.types +++ b/tests/baselines/reference/exportsAndImports3-es6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports3.js b/tests/baselines/reference/exportsAndImports3.js index 4dfa0411946e0..77ac28f4800e6 100644 --- a/tests/baselines/reference/exportsAndImports3.js +++ b/tests/baselines/reference/exportsAndImports3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports3.ts] //// //// [t1.ts] - export var v = 1; export function f() { } export class C { diff --git a/tests/baselines/reference/exportsAndImports3.symbols b/tests/baselines/reference/exportsAndImports3.symbols index a46d7df2a68a4..f71014281c2a6 100644 --- a/tests/baselines/reference/exportsAndImports3.symbols +++ b/tests/baselines/reference/exportsAndImports3.symbols @@ -1,75 +1,74 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; ->v : Symbol(v, Decl(t1.ts, 1, 10)) +>v : Symbol(v, Decl(t1.ts, 0, 10)) export function f() { } ->f : Symbol(f, Decl(t1.ts, 1, 17)) +>f : Symbol(f, Decl(t1.ts, 0, 17)) export class C { ->C : Symbol(C, Decl(t1.ts, 2, 23)) +>C : Symbol(C, Decl(t1.ts, 1, 23)) } export interface I { ->I : Symbol(I, Decl(t1.ts, 4, 1)) +>I : Symbol(I, Decl(t1.ts, 3, 1)) } export enum E { ->E : Symbol(E, Decl(t1.ts, 6, 1)) +>E : Symbol(E, Decl(t1.ts, 5, 1)) A, B, C ->A : Symbol(E.A, Decl(t1.ts, 7, 15)) ->B : Symbol(E.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 6, 15)) +>B : Symbol(E.B, Decl(t1.ts, 7, 6)) +>C : Symbol(E.C, Decl(t1.ts, 7, 9)) } export const enum D { ->D : Symbol(D, Decl(t1.ts, 9, 1)) +>D : Symbol(D, Decl(t1.ts, 8, 1)) A, B, C ->A : Symbol(D.A, Decl(t1.ts, 10, 21)) ->B : Symbol(D.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 9, 21)) +>B : Symbol(D.B, Decl(t1.ts, 10, 6)) +>C : Symbol(D.C, Decl(t1.ts, 10, 9)) } export module M { ->M : Symbol(M, Decl(t1.ts, 12, 1)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) export var x; ->x : Symbol(x, Decl(t1.ts, 14, 14)) +>x : Symbol(x, Decl(t1.ts, 13, 14)) } export module N { ->N : Symbol(N, Decl(t1.ts, 15, 1)) +>N : Symbol(N, Decl(t1.ts, 14, 1)) export interface I { ->I : Symbol(I, Decl(t1.ts, 16, 17)) +>I : Symbol(I, Decl(t1.ts, 15, 17)) } } export type T = number; ->T : Symbol(T, Decl(t1.ts, 19, 1)) +>T : Symbol(T, Decl(t1.ts, 18, 1)) export import a = M.x; ->a : Symbol(a, Decl(t1.ts, 20, 23)) ->M : Symbol(M, Decl(t1.ts, 12, 1)) ->x : Symbol(a, Decl(t1.ts, 14, 14)) +>a : Symbol(a, Decl(t1.ts, 19, 23)) +>M : Symbol(M, Decl(t1.ts, 11, 1)) +>x : Symbol(a, Decl(t1.ts, 13, 14)) export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 }; ->v : Symbol(v1, Decl(t1.ts, 23, 8)) ->v1 : Symbol(v1, Decl(t1.ts, 23, 8)) ->f : Symbol(f1, Decl(t1.ts, 23, 17)) ->f1 : Symbol(f1, Decl(t1.ts, 23, 17)) ->C : Symbol(C1, Decl(t1.ts, 23, 26)) ->C1 : Symbol(C1, Decl(t1.ts, 23, 26)) ->I : Symbol(I1, Decl(t1.ts, 23, 35)) ->I1 : Symbol(I1, Decl(t1.ts, 23, 35)) ->E : Symbol(E1, Decl(t1.ts, 23, 44)) ->E1 : Symbol(E1, Decl(t1.ts, 23, 44)) ->D : Symbol(D1, Decl(t1.ts, 23, 53)) ->D1 : Symbol(D1, Decl(t1.ts, 23, 53)) ->M : Symbol(M1, Decl(t1.ts, 23, 62)) ->M1 : Symbol(M1, Decl(t1.ts, 23, 62)) ->N : Symbol(N1, Decl(t1.ts, 23, 71)) ->N1 : Symbol(N1, Decl(t1.ts, 23, 71)) ->T : Symbol(T1, Decl(t1.ts, 23, 80)) ->T1 : Symbol(T1, Decl(t1.ts, 23, 80)) ->a : Symbol(a1, Decl(t1.ts, 23, 89)) ->a1 : Symbol(a1, Decl(t1.ts, 23, 89)) +>v : Symbol(v1, Decl(t1.ts, 22, 8)) +>v1 : Symbol(v1, Decl(t1.ts, 22, 8)) +>f : Symbol(f1, Decl(t1.ts, 22, 17)) +>f1 : Symbol(f1, Decl(t1.ts, 22, 17)) +>C : Symbol(C1, Decl(t1.ts, 22, 26)) +>C1 : Symbol(C1, Decl(t1.ts, 22, 26)) +>I : Symbol(I1, Decl(t1.ts, 22, 35)) +>I1 : Symbol(I1, Decl(t1.ts, 22, 35)) +>E : Symbol(E1, Decl(t1.ts, 22, 44)) +>E1 : Symbol(E1, Decl(t1.ts, 22, 44)) +>D : Symbol(D1, Decl(t1.ts, 22, 53)) +>D1 : Symbol(D1, Decl(t1.ts, 22, 53)) +>M : Symbol(M1, Decl(t1.ts, 22, 62)) +>M1 : Symbol(M1, Decl(t1.ts, 22, 62)) +>N : Symbol(N1, Decl(t1.ts, 22, 71)) +>N1 : Symbol(N1, Decl(t1.ts, 22, 71)) +>T : Symbol(T1, Decl(t1.ts, 22, 80)) +>T1 : Symbol(T1, Decl(t1.ts, 22, 80)) +>a : Symbol(a1, Decl(t1.ts, 22, 89)) +>a1 : Symbol(a1, Decl(t1.ts, 22, 89)) === tests/cases/conformance/es6/modules/t2.ts === export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImports3.types b/tests/baselines/reference/exportsAndImports3.types index 5292f01af0de3..afb32cb9c541f 100644 --- a/tests/baselines/reference/exportsAndImports3.types +++ b/tests/baselines/reference/exportsAndImports3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - export var v = 1; >v : number >1 : 1 diff --git a/tests/baselines/reference/exportsAndImports4-amd.js b/tests/baselines/reference/exportsAndImports4-amd.js index ed31f42ebc781..52a41a0a4512b 100644 --- a/tests/baselines/reference/exportsAndImports4-amd.js +++ b/tests/baselines/reference/exportsAndImports4-amd.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports4-amd.ts] //// //// [t1.ts] - export default "hello"; //// [t2.ts] diff --git a/tests/baselines/reference/exportsAndImports4-amd.symbols b/tests/baselines/reference/exportsAndImports4-amd.symbols index 0204d9bd58648..ed5225763983e 100644 --- a/tests/baselines/reference/exportsAndImports4-amd.symbols +++ b/tests/baselines/reference/exportsAndImports4-amd.symbols @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : Symbol(f2, Decl(t3.ts, 14, 32)) === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4-amd.types b/tests/baselines/reference/exportsAndImports4-amd.types index dfddd897e5918..6127765014a57 100644 --- a/tests/baselines/reference/exportsAndImports4-amd.types +++ b/tests/baselines/reference/exportsAndImports4-amd.types @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : "hello" === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4-es6.js b/tests/baselines/reference/exportsAndImports4-es6.js index d8c51d03bb1de..ee35571942f6c 100644 --- a/tests/baselines/reference/exportsAndImports4-es6.js +++ b/tests/baselines/reference/exportsAndImports4-es6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts] //// //// [t1.ts] - export default "hello"; //// [t2.ts] diff --git a/tests/baselines/reference/exportsAndImports4-es6.symbols b/tests/baselines/reference/exportsAndImports4-es6.symbols index 0204d9bd58648..ed5225763983e 100644 --- a/tests/baselines/reference/exportsAndImports4-es6.symbols +++ b/tests/baselines/reference/exportsAndImports4-es6.symbols @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : Symbol(f2, Decl(t3.ts, 14, 32)) === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4-es6.types b/tests/baselines/reference/exportsAndImports4-es6.types index dfddd897e5918..6127765014a57 100644 --- a/tests/baselines/reference/exportsAndImports4-es6.types +++ b/tests/baselines/reference/exportsAndImports4-es6.types @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : "hello" === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4.js b/tests/baselines/reference/exportsAndImports4.js index 99f81a6b87542..efb93eeebf62e 100644 --- a/tests/baselines/reference/exportsAndImports4.js +++ b/tests/baselines/reference/exportsAndImports4.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImports4.ts] //// //// [t1.ts] - export default "hello"; //// [t2.ts] diff --git a/tests/baselines/reference/exportsAndImports4.symbols b/tests/baselines/reference/exportsAndImports4.symbols index 0204d9bd58648..ed5225763983e 100644 --- a/tests/baselines/reference/exportsAndImports4.symbols +++ b/tests/baselines/reference/exportsAndImports4.symbols @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : Symbol(f2, Decl(t3.ts, 14, 32)) === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImports4.types b/tests/baselines/reference/exportsAndImports4.types index dfddd897e5918..6127765014a57 100644 --- a/tests/baselines/reference/exportsAndImports4.types +++ b/tests/baselines/reference/exportsAndImports4.types @@ -62,7 +62,6 @@ export { a, b, c, d, e1, e2, f1, f2 }; >f2 : "hello" === tests/cases/conformance/es6/modules/t1.ts === - -No type information for this code.export default "hello"; +export default "hello"; No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.errors.txt b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.errors.txt index 6d443464d99f0..767af3d75bed4 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.errors.txt +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.errors.txt @@ -2,7 +2,6 @@ tests/cases/conformance/es6/modules/t3.ts(1,17): error TS1214: Identifier expect ==== tests/cases/conformance/es6/modules/t1.ts (0 errors) ==== - let set = { set foo(x: number) { } diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.js b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.js index 068afdc346b57..1cd4fee3c7924 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.js +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithContextualKeywordNames01.ts] //// //// [t1.ts] - let set = { set foo(x: number) { } diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.js b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.js index 8b1deff064f50..cf1976e5b03f2 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.js +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithContextualKeywordNames02.ts] //// //// [t1.ts] - let as = 100; export { as as return, as }; diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.symbols b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.symbols index 4bc53e9d4b684..a8945c88cc69a 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.symbols +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/es6/modules/t1.ts === - let as = 100; ->as : Symbol(as, Decl(t1.ts, 1, 3)) +>as : Symbol(as, Decl(t1.ts, 0, 3)) export { as as return, as }; ->as : Symbol(return, Decl(t1.ts, 3, 8)) ->return : Symbol(return, Decl(t1.ts, 3, 8)) ->as : Symbol(as, Decl(t1.ts, 3, 22)) +>as : Symbol(return, Decl(t1.ts, 2, 8)) +>return : Symbol(return, Decl(t1.ts, 2, 8)) +>as : Symbol(as, Decl(t1.ts, 2, 22)) === tests/cases/conformance/es6/modules/t2.ts === import * as as from "./t1"; @@ -14,15 +13,15 @@ import * as as from "./t1"; var x = as.as; >x : Symbol(x, Decl(t2.ts, 1, 3)) ->as.as : Symbol(as.as, Decl(t1.ts, 3, 22)) +>as.as : Symbol(as.as, Decl(t1.ts, 2, 22)) >as : Symbol(as, Decl(t2.ts, 0, 6)) ->as : Symbol(as.as, Decl(t1.ts, 3, 22)) +>as : Symbol(as.as, Decl(t1.ts, 2, 22)) var y = as.return; >y : Symbol(y, Decl(t2.ts, 2, 3)) ->as.return : Symbol(as.return, Decl(t1.ts, 3, 8)) +>as.return : Symbol(as.return, Decl(t1.ts, 2, 8)) >as : Symbol(as, Decl(t2.ts, 0, 6)) ->return : Symbol(as.return, Decl(t1.ts, 3, 8)) +>return : Symbol(as.return, Decl(t1.ts, 2, 8)) === tests/cases/conformance/es6/modules/t3.ts === import { as as as } from "./t1"; diff --git a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.types b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.types index c12e84e320bd0..5bffab447e902 100644 --- a/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.types +++ b/tests/baselines/reference/exportsAndImportsWithContextualKeywordNames02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/t1.ts === - let as = 100; >as : number >100 : 100 diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores1.errors.txt b/tests/baselines/reference/exportsAndImportsWithUnderscores1.errors.txt index 7a65dd62c2bdb..33d15265cb9aa 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores1.errors.txt +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/modules/m1.ts(6,5): error TS1005: ',' expected. +tests/cases/conformance/es6/modules/m1.ts(5,5): error TS1005: ',' expected. ==== tests/cases/conformance/es6/modules/m1.ts (1 errors) ==== - var R: any export default R = { "__": 20, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores1.js b/tests/baselines/reference/exportsAndImportsWithUnderscores1.js index 207d2948fa471..284537252fe70 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores1.js +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithUnderscores1.ts] //// //// [m1.ts] - var R: any export default R = { "__": 20, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores2.js b/tests/baselines/reference/exportsAndImportsWithUnderscores2.js index a53d4662e9766..90cbc11b95b10 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores2.js +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithUnderscores2.ts] //// //// [m1.ts] - var R: any export default R = { "__esmodule": true, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores2.symbols b/tests/baselines/reference/exportsAndImportsWithUnderscores2.symbols index d5f5ef17a62c2..7121472886a02 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores2.symbols +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores2.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/m1.ts === - var R: any ->R : Symbol(R, Decl(m1.ts, 1, 3)) +>R : Symbol(R, Decl(m1.ts, 0, 3)) export default R = { ->R : Symbol(R, Decl(m1.ts, 1, 3)) +>R : Symbol(R, Decl(m1.ts, 0, 3)) "__esmodule": true, "__proto__": {} diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores2.types b/tests/baselines/reference/exportsAndImportsWithUnderscores2.types index 3b86789cc44d0..e38209b842ff1 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores2.types +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - var R: any >R : any diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores3.js b/tests/baselines/reference/exportsAndImportsWithUnderscores3.js index 3a5bba1deed58..0aead5f1f8bbc 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores3.js +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithUnderscores3.ts] //// //// [m1.ts] - var R: any export default R = { "___": 30, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores3.symbols b/tests/baselines/reference/exportsAndImportsWithUnderscores3.symbols index cd4ba38e8c9db..c58f1a11f76e5 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores3.symbols +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores3.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/m1.ts === - var R: any ->R : Symbol(R, Decl(m1.ts, 1, 3)) +>R : Symbol(R, Decl(m1.ts, 0, 3)) export default R = { ->R : Symbol(R, Decl(m1.ts, 1, 3)) +>R : Symbol(R, Decl(m1.ts, 0, 3)) "___": 30, "___hello": 21, diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores3.types b/tests/baselines/reference/exportsAndImportsWithUnderscores3.types index b860928aa6208..0e6bb89523714 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores3.types +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - var R: any >R : any diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores4.js b/tests/baselines/reference/exportsAndImportsWithUnderscores4.js index 718d048b9a27a..ad50ca41efff8 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores4.js +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores4.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/exportsAndImportsWithUnderscores4.ts] //// //// [m1.ts] - declare var console: any; export function _() { console.log("_"); diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores4.symbols b/tests/baselines/reference/exportsAndImportsWithUnderscores4.symbols index a8fb3f307b5bf..075b5a80862a6 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores4.symbols +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores4.symbols @@ -1,49 +1,48 @@ === tests/cases/conformance/es6/modules/m1.ts === - declare var console: any; ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) export function _() { ->_ : Symbol(_, Decl(m1.ts, 1, 25)) +>_ : Symbol(_, Decl(m1.ts, 0, 25)) console.log("_"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function __() { ->__ : Symbol(__, Decl(m1.ts, 4, 1)) +>__ : Symbol(__, Decl(m1.ts, 3, 1)) console.log("__"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function ___() { ->___ : Symbol(___, Decl(m1.ts, 7, 1)) +>___ : Symbol(___, Decl(m1.ts, 6, 1)) console.log("___"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function _hi() { ->_hi : Symbol(_hi, Decl(m1.ts, 10, 1)) +>_hi : Symbol(_hi, Decl(m1.ts, 9, 1)) console.log("_hi"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function __proto() { ->__proto : Symbol(__proto, Decl(m1.ts, 13, 1)) +>__proto : Symbol(__proto, Decl(m1.ts, 12, 1)) console.log("__proto"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function __esmodule() { ->__esmodule : Symbol(__esmodule, Decl(m1.ts, 16, 1)) +>__esmodule : Symbol(__esmodule, Decl(m1.ts, 15, 1)) console.log("__esmodule"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } export function ___hello(){ ->___hello : Symbol(___hello, Decl(m1.ts, 19, 1)) +>___hello : Symbol(___hello, Decl(m1.ts, 18, 1)) console.log("___hello"); ->console : Symbol(console, Decl(m1.ts, 1, 11)) +>console : Symbol(console, Decl(m1.ts, 0, 11)) } === tests/cases/conformance/es6/modules/m2.ts === diff --git a/tests/baselines/reference/exportsAndImportsWithUnderscores4.types b/tests/baselines/reference/exportsAndImportsWithUnderscores4.types index cf339db5deeac..7fb5a0b3c8842 100644 --- a/tests/baselines/reference/exportsAndImportsWithUnderscores4.types +++ b/tests/baselines/reference/exportsAndImportsWithUnderscores4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - declare var console: any; >console : any diff --git a/tests/baselines/reference/exportsInAmbientModules1.js b/tests/baselines/reference/exportsInAmbientModules1.js index 4370b19740355..cc9d62cd7dad0 100644 --- a/tests/baselines/reference/exportsInAmbientModules1.js +++ b/tests/baselines/reference/exportsInAmbientModules1.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/exportsInAmbientModules1.ts] //// //// [external.d.ts] - export var x: number //// [main.ts] - declare module "M" { export {x} from "external" } diff --git a/tests/baselines/reference/exportsInAmbientModules1.symbols b/tests/baselines/reference/exportsInAmbientModules1.symbols index 58cdf8663a79a..eee96af50f92e 100644 --- a/tests/baselines/reference/exportsInAmbientModules1.symbols +++ b/tests/baselines/reference/exportsInAmbientModules1.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export var x: number ->x : Symbol(x, Decl(external.d.ts, 1, 10)) +>x : Symbol(x, Decl(external.d.ts, 0, 10)) === tests/cases/compiler/main.ts === - declare module "M" { export {x} from "external" ->x : Symbol(x, Decl(main.ts, 2, 12)) +>x : Symbol(x, Decl(main.ts, 1, 12)) } diff --git a/tests/baselines/reference/exportsInAmbientModules1.types b/tests/baselines/reference/exportsInAmbientModules1.types index 490a63caf925a..4d0c1cbd26e81 100644 --- a/tests/baselines/reference/exportsInAmbientModules1.types +++ b/tests/baselines/reference/exportsInAmbientModules1.types @@ -1,10 +1,8 @@ === tests/cases/compiler/external.d.ts === - export var x: number >x : number === tests/cases/compiler/main.ts === - declare module "M" { export {x} from "external" >x : number diff --git a/tests/baselines/reference/exportsInAmbientModules2.js b/tests/baselines/reference/exportsInAmbientModules2.js index f08ff17f8ba5b..d7ecccaebe1b4 100644 --- a/tests/baselines/reference/exportsInAmbientModules2.js +++ b/tests/baselines/reference/exportsInAmbientModules2.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/exportsInAmbientModules2.ts] //// //// [external.d.ts] - export default class C {} //// [main.ts] - declare module "M" { export * from "external" } diff --git a/tests/baselines/reference/exportsInAmbientModules2.symbols b/tests/baselines/reference/exportsInAmbientModules2.symbols index 54e8b44ec3418..3cad91fab62d3 100644 --- a/tests/baselines/reference/exportsInAmbientModules2.symbols +++ b/tests/baselines/reference/exportsInAmbientModules2.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export default class C {} >C : Symbol(C, Decl(external.d.ts, 0, 0)) === tests/cases/compiler/main.ts === - -No type information for this code.declare module "M" { +declare module "M" { No type information for this code. export * from "external" No type information for this code.} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/exportsInAmbientModules2.types b/tests/baselines/reference/exportsInAmbientModules2.types index 3472a35bf7537..0c32c1c62a8c8 100644 --- a/tests/baselines/reference/exportsInAmbientModules2.types +++ b/tests/baselines/reference/exportsInAmbientModules2.types @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export default class C {} >C : C === tests/cases/compiler/main.ts === - -No type information for this code.declare module "M" { +declare module "M" { No type information for this code. export * from "external" No type information for this code.} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/extendFromAny.errors.txt b/tests/baselines/reference/extendFromAny.errors.txt new file mode 100644 index 0000000000000..0a40edbaf7a08 --- /dev/null +++ b/tests/baselines/reference/extendFromAny.errors.txt @@ -0,0 +1,21 @@ +tests/cases/compiler/extendFromAny.ts(8,9): error TS2339: Property 'length' does not exist on type 'number'. +tests/cases/compiler/extendFromAny.ts(9,10): error TS2339: Property 'length' does not exist on type 'number'. + + +==== tests/cases/compiler/extendFromAny.ts (2 errors) ==== + declare var Base: any; + class C extends Base { + known = 1; + static sknown = 2; + } + + let c = new C(); + c.known.length; // error, 'known' has no 'length' property + ~~~~~~ +!!! error TS2339: Property 'length' does not exist on type 'number'. + C.sknown.length; // error, 'sknown' has no 'length' property + ~~~~~~ +!!! error TS2339: Property 'length' does not exist on type 'number'. + c.unknown.length; // ok, unknown: any + C.sunknown.length; // ok: sunknown: any + \ No newline at end of file diff --git a/tests/baselines/reference/extendFromAny.js b/tests/baselines/reference/extendFromAny.js new file mode 100644 index 0000000000000..f2a7f945cc950 --- /dev/null +++ b/tests/baselines/reference/extendFromAny.js @@ -0,0 +1,40 @@ +//// [extendFromAny.ts] +declare var Base: any; +class C extends Base { + known = 1; + static sknown = 2; +} + +let c = new C(); +c.known.length; // error, 'known' has no 'length' property +C.sknown.length; // error, 'sknown' has no 'length' property +c.unknown.length; // ok, unknown: any +C.sunknown.length; // ok: sunknown: any + + +//// [extendFromAny.js] +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var C = (function (_super) { + __extends(C, _super); + function C() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.known = 1; + return _this; + } + return C; +}(Base)); +C.sknown = 2; +var c = new C(); +c.known.length; // error, 'known' has no 'length' property +C.sknown.length; // error, 'sknown' has no 'length' property +c.unknown.length; // ok, unknown: any +C.sunknown.length; // ok: sunknown: any diff --git a/tests/baselines/reference/extendsUntypedModule.errors.txt b/tests/baselines/reference/extendsUntypedModule.errors.txt index 9a1c423535261..4667f16b74a6e 100644 --- a/tests/baselines/reference/extendsUntypedModule.errors.txt +++ b/tests/baselines/reference/extendsUntypedModule.errors.txt @@ -1,14 +1,18 @@ -/a.ts(2,17): error TS2507: Type 'any' is not a constructor function type. +/a.ts(2,8): error TS6133: 'Bar' is declared but never used. ==== /a.ts (1 errors) ==== import Foo from "foo"; - class A extends Foo { } - ~~~ -!!! error TS2507: Type 'any' is not a constructor function type. + import Bar from "bar"; // error: unused + ~~~ +!!! error TS6133: 'Bar' is declared but never used. + export class A extends Foo { } ==== /node_modules/foo/index.js (0 errors) ==== // Test that extending an untyped module is an error, unlike extending unknownSymbol. This file is not read. + +==== /node_modules/bar/index.js (0 errors) ==== + Nor is this one. \ No newline at end of file diff --git a/tests/baselines/reference/extendsUntypedModule.js b/tests/baselines/reference/extendsUntypedModule.js index f86ded7e6cb9f..5ccd7babe9890 100644 --- a/tests/baselines/reference/extendsUntypedModule.js +++ b/tests/baselines/reference/extendsUntypedModule.js @@ -5,9 +5,13 @@ This file is not read. +//// [index.js] +Nor is this one. + //// [a.ts] import Foo from "foo"; -class A extends Foo { } +import Bar from "bar"; // error: unused +export class A extends Foo { } //// [a.js] @@ -31,3 +35,4 @@ var A = (function (_super) { } return A; }(foo_1["default"])); +exports.A = A; diff --git a/tests/baselines/reference/externalModuleExportingGenericClass.errors.txt b/tests/baselines/reference/externalModuleExportingGenericClass.errors.txt index 7825345a1b57f..a1db92b4e4658 100644 --- a/tests/baselines/reference/externalModuleExportingGenericClass.errors.txt +++ b/tests/baselines/reference/externalModuleExportingGenericClass.errors.txt @@ -10,7 +10,6 @@ tests/cases/compiler/externalModuleExportingGenericClass_file1.ts(2,8): error TS var v3: number = (new a()).foo; ==== tests/cases/compiler/externalModuleExportingGenericClass_file0.ts (0 errors) ==== - class C { foo: T; } diff --git a/tests/baselines/reference/externalModuleExportingGenericClass.js b/tests/baselines/reference/externalModuleExportingGenericClass.js index 33aa1776e9448..339eaec2cbfa7 100644 --- a/tests/baselines/reference/externalModuleExportingGenericClass.js +++ b/tests/baselines/reference/externalModuleExportingGenericClass.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/externalModuleExportingGenericClass.ts] //// //// [externalModuleExportingGenericClass_file0.ts] - class C { foo: T; } diff --git a/tests/baselines/reference/externalModuleImmutableBindings.errors.txt b/tests/baselines/reference/externalModuleImmutableBindings.errors.txt index 815b5847458e1..58e411e1035c5 100644 --- a/tests/baselines/reference/externalModuleImmutableBindings.errors.txt +++ b/tests/baselines/reference/externalModuleImmutableBindings.errors.txt @@ -1,32 +1,31 @@ +tests/cases/compiler/f2.ts(6,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(7,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(8,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(9,7): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(8,7): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(11,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(12,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(13,7): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/f2.ts(16,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(17,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(18,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(19,8): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(18,8): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(21,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(22,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(23,8): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/f2.ts(26,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(27,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(28,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(29,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(30,12): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/f2.ts(30,12): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. tests/cases/compiler/f2.ts(31,12): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. -tests/cases/compiler/f2.ts(32,12): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. +tests/cases/compiler/f2.ts(35,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(36,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(37,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. tests/cases/compiler/f2.ts(38,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. -tests/cases/compiler/f2.ts(39,13): error TS2540: Cannot assign to 'x' because it is a constant or a read-only property. +tests/cases/compiler/f2.ts(39,13): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. tests/cases/compiler/f2.ts(40,13): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. -tests/cases/compiler/f2.ts(41,13): error TS2339: Property 'blah' does not exist on type 'typeof "tests/cases/compiler/f1"'. ==== tests/cases/compiler/f1.ts (0 errors) ==== export var x = 1; ==== tests/cases/compiler/f2.ts (22 errors) ==== - // all mutations below are illegal and should be fixed import * as stuff from './f1'; diff --git a/tests/baselines/reference/externalModuleImmutableBindings.js b/tests/baselines/reference/externalModuleImmutableBindings.js index 7e2a78a4728b6..d6f5913f5d1d3 100644 --- a/tests/baselines/reference/externalModuleImmutableBindings.js +++ b/tests/baselines/reference/externalModuleImmutableBindings.js @@ -4,7 +4,6 @@ export var x = 1; //// [f2.ts] - // all mutations below are illegal and should be fixed import * as stuff from './f1'; diff --git a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.js b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.js index fa98fbe222353..972b4b3b2eab2 100644 --- a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.js +++ b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.js @@ -1,5 +1,4 @@ //// [externalModuleWithoutCompilerFlag1.ts] - // Not on line 0 because we want to verify the error is placed in the appropriate location. export module M { } diff --git a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.symbols b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.symbols index 21426e15e5d07..0abc0ec0bda79 100644 --- a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.symbols +++ b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/externalModuleWithoutCompilerFlag1.ts === - // Not on line 0 because we want to verify the error is placed in the appropriate location. export module M { >M : Symbol(M, Decl(externalModuleWithoutCompilerFlag1.ts, 0, 0)) diff --git a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.types b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.types index 26d360d63a9b3..39d1f7c26120f 100644 --- a/tests/baselines/reference/externalModuleWithoutCompilerFlag1.types +++ b/tests/baselines/reference/externalModuleWithoutCompilerFlag1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/externalModuleWithoutCompilerFlag1.ts === - // Not on line 0 because we want to verify the error is placed in the appropriate location. export module M { >M : any diff --git a/tests/baselines/reference/fallFromLastCase1.js b/tests/baselines/reference/fallFromLastCase1.js index 3c2461db514c2..717762eee8814 100644 --- a/tests/baselines/reference/fallFromLastCase1.js +++ b/tests/baselines/reference/fallFromLastCase1.js @@ -1,5 +1,4 @@ //// [fallFromLastCase1.ts] - declare function use(a: string); function foo1(a: number) { diff --git a/tests/baselines/reference/fallFromLastCase1.symbols b/tests/baselines/reference/fallFromLastCase1.symbols index c4967e5e77535..711374a9a9623 100644 --- a/tests/baselines/reference/fallFromLastCase1.symbols +++ b/tests/baselines/reference/fallFromLastCase1.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/fallFromLastCase1.ts === - declare function use(a: string); >use : Symbol(use, Decl(fallFromLastCase1.ts, 0, 0)) ->a : Symbol(a, Decl(fallFromLastCase1.ts, 1, 21)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 0, 21)) function foo1(a: number) { ->foo1 : Symbol(foo1, Decl(fallFromLastCase1.ts, 1, 32)) ->a : Symbol(a, Decl(fallFromLastCase1.ts, 3, 14)) +>foo1 : Symbol(foo1, Decl(fallFromLastCase1.ts, 0, 32)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 2, 14)) switch (a) { ->a : Symbol(a, Decl(fallFromLastCase1.ts, 3, 14)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 2, 14)) case 1: use("1"); @@ -24,11 +23,11 @@ function foo1(a: number) { function foo2(a: number) { ->foo2 : Symbol(foo2, Decl(fallFromLastCase1.ts, 11, 1)) ->a : Symbol(a, Decl(fallFromLastCase1.ts, 14, 14)) +>foo2 : Symbol(foo2, Decl(fallFromLastCase1.ts, 10, 1)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 13, 14)) switch (a) { ->a : Symbol(a, Decl(fallFromLastCase1.ts, 14, 14)) +>a : Symbol(a, Decl(fallFromLastCase1.ts, 13, 14)) case 1: use("1"); diff --git a/tests/baselines/reference/fallFromLastCase1.types b/tests/baselines/reference/fallFromLastCase1.types index 0353ae88387a0..b67bf9e0bbd61 100644 --- a/tests/baselines/reference/fallFromLastCase1.types +++ b/tests/baselines/reference/fallFromLastCase1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/fallFromLastCase1.ts === - declare function use(a: string); >use : (a: string) => any >a : string diff --git a/tests/baselines/reference/fallFromLastCase2.errors.txt b/tests/baselines/reference/fallFromLastCase2.errors.txt index ccf7f6ebc1b38..fcf3251ac3f58 100644 --- a/tests/baselines/reference/fallFromLastCase2.errors.txt +++ b/tests/baselines/reference/fallFromLastCase2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/fallFromLastCase2.ts(9,9): error TS7029: Fallthrough case in switch. -tests/cases/compiler/fallFromLastCase2.ts(22,9): error TS7029: Fallthrough case in switch. +tests/cases/compiler/fallFromLastCase2.ts(8,9): error TS7029: Fallthrough case in switch. +tests/cases/compiler/fallFromLastCase2.ts(21,9): error TS7029: Fallthrough case in switch. ==== tests/cases/compiler/fallFromLastCase2.ts (2 errors) ==== - declare function use(a: string); function foo1(a: number) { diff --git a/tests/baselines/reference/fallFromLastCase2.js b/tests/baselines/reference/fallFromLastCase2.js index fd1d7c20d073e..44f9608d6ba6e 100644 --- a/tests/baselines/reference/fallFromLastCase2.js +++ b/tests/baselines/reference/fallFromLastCase2.js @@ -1,5 +1,4 @@ //// [fallFromLastCase2.ts] - declare function use(a: string); function foo1(a: number) { diff --git a/tests/baselines/reference/fatarrowfunctions.js b/tests/baselines/reference/fatarrowfunctions.js index eb57d1a981712..d3ec0c47054f2 100644 --- a/tests/baselines/reference/fatarrowfunctions.js +++ b/tests/baselines/reference/fatarrowfunctions.js @@ -1,5 +1,4 @@ //// [fatarrowfunctions.ts] - function foo(x:any) { return x(); } diff --git a/tests/baselines/reference/fatarrowfunctions.symbols b/tests/baselines/reference/fatarrowfunctions.symbols index 6ed865b091459..dae8380dc7379 100644 --- a/tests/baselines/reference/fatarrowfunctions.symbols +++ b/tests/baselines/reference/fatarrowfunctions.symbols @@ -1,33 +1,41 @@ === tests/cases/compiler/fatarrowfunctions.ts === - function foo(x:any) { >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 1, 13)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 0, 13)) return x(); ->x : Symbol(x, Decl(fatarrowfunctions.ts, 1, 13)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 0, 13)) } foo((x:number,y,z)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 5, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 5, 14)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 5, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 5, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 5, 14)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 5, 16)) + +foo((x,y,z)=>{return x+y+z;}); +>foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 6, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 14)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 16)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 9)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 6, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 14)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 16)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 9)) -foo((x,y,z)=>{return x+y+z;}); +foo((x,y:number,z)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 7, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 7, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 9)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 16)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 7, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 7, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 9)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 16)) -foo((x,y:number,z)=>{return x+y+z;}); +foo((x,y:number,z:number)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 8, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 8, 7)) @@ -36,46 +44,46 @@ foo((x,y:number,z)=>{return x+y+z;}); >y : Symbol(y, Decl(fatarrowfunctions.ts, 8, 7)) >z : Symbol(z, Decl(fatarrowfunctions.ts, 8, 16)) -foo((x,y:number,z:number)=>{return x+y+z;}); +foo((x,y,z:number)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 9, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 9, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 16)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 9)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 9, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 9, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 16)) - -foo((x,y,z:number)=>{return x+y+z;}); ->foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 10, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 10, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 10, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 10, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 10, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 10, 9)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 9)) foo(()=>{return 0;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) foo((x:number,y,z)=>x+y+z); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 12, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 12, 14)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 12, 16)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 12, 5)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 12, 14)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 12, 16)) + +foo((x,y,z)=>x+y+z); +>foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 13, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 14)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 16)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 9)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 13, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 14)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 16)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 7)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 9)) -foo((x,y,z)=>x+y+z); +foo((x,y:number,z)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 14, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 14, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 9)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 16)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 14, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 14, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 9)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 16)) -foo((x,y:number,z)=>{return x+y+z;}); +foo((x,y:number,z:number)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 15, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 15, 7)) @@ -84,23 +92,14 @@ foo((x,y:number,z)=>{return x+y+z;}); >y : Symbol(y, Decl(fatarrowfunctions.ts, 15, 7)) >z : Symbol(z, Decl(fatarrowfunctions.ts, 15, 16)) -foo((x,y:number,z:number)=>{return x+y+z;}); +foo((x,y,z:number)=>{return x+y+z;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 16, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 16, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 16)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 9)) >x : Symbol(x, Decl(fatarrowfunctions.ts, 16, 5)) >y : Symbol(y, Decl(fatarrowfunctions.ts, 16, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 16)) - -foo((x,y,z:number)=>{return x+y+z;}); ->foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 17, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 17, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 17, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 17, 5)) ->y : Symbol(y, Decl(fatarrowfunctions.ts, 17, 7)) ->z : Symbol(z, Decl(fatarrowfunctions.ts, 17, 9)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 9)) foo(()=>{return 0;}); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) @@ -108,61 +107,61 @@ foo(()=>{return 0;}); foo(((x) => x)); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 21, 6)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 21, 6)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 20, 6)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 20, 6)) foo(x => x*x); >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 22, 4)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 22, 4)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 22, 4)) var y = x => x*x; ->y : Symbol(y, Decl(fatarrowfunctions.ts, 25, 3)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7)) +>y : Symbol(y, Decl(fatarrowfunctions.ts, 24, 3)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 24, 7)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 24, 7)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 24, 7)) var z = (x:number) => x*x; ->z : Symbol(z, Decl(fatarrowfunctions.ts, 26, 3)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9)) ->x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9)) +>z : Symbol(z, Decl(fatarrowfunctions.ts, 25, 3)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 9)) +>x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 9)) var w = () => 3; ->w : Symbol(w, Decl(fatarrowfunctions.ts, 28, 3)) +>w : Symbol(w, Decl(fatarrowfunctions.ts, 27, 3)) function ternaryTest(isWhile:boolean) { ->ternaryTest : Symbol(ternaryTest, Decl(fatarrowfunctions.ts, 28, 16)) ->isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 30, 21)) +>ternaryTest : Symbol(ternaryTest, Decl(fatarrowfunctions.ts, 27, 16)) +>isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 29, 21)) var f = isWhile ? function (n) { return n > 0; } : function (n) { return n === 0; }; ->f : Symbol(f, Decl(fatarrowfunctions.ts, 32, 19)) ->isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 30, 21)) ->n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 44)) ->n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 44)) ->n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 77)) ->n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 77)) +>f : Symbol(f, Decl(fatarrowfunctions.ts, 31, 19)) +>isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 29, 21)) +>n : Symbol(n, Decl(fatarrowfunctions.ts, 31, 44)) +>n : Symbol(n, Decl(fatarrowfunctions.ts, 31, 44)) +>n : Symbol(n, Decl(fatarrowfunctions.ts, 31, 77)) +>n : Symbol(n, Decl(fatarrowfunctions.ts, 31, 77)) } declare function setTimeout(expression: any, msec?: number, language?: any): number; ->setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 34, 1)) ->expression : Symbol(expression, Decl(fatarrowfunctions.ts, 36, 28)) ->msec : Symbol(msec, Decl(fatarrowfunctions.ts, 36, 44)) ->language : Symbol(language, Decl(fatarrowfunctions.ts, 36, 59)) +>setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 33, 1)) +>expression : Symbol(expression, Decl(fatarrowfunctions.ts, 35, 28)) +>msec : Symbol(msec, Decl(fatarrowfunctions.ts, 35, 44)) +>language : Symbol(language, Decl(fatarrowfunctions.ts, 35, 59)) var messenger = { ->messenger : Symbol(messenger, Decl(fatarrowfunctions.ts, 38, 3)) +>messenger : Symbol(messenger, Decl(fatarrowfunctions.ts, 37, 3)) message: "Hello World", ->message : Symbol(message, Decl(fatarrowfunctions.ts, 38, 17)) +>message : Symbol(message, Decl(fatarrowfunctions.ts, 37, 17)) start: function() { ->start : Symbol(start, Decl(fatarrowfunctions.ts, 39, 27)) +>start : Symbol(start, Decl(fatarrowfunctions.ts, 38, 27)) setTimeout(() => { this.message.toString(); }, 3000); ->setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 34, 1)) +>setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 33, 1)) } }; diff --git a/tests/baselines/reference/fatarrowfunctions.types b/tests/baselines/reference/fatarrowfunctions.types index 304c341c91640..6ed37080a2360 100644 --- a/tests/baselines/reference/fatarrowfunctions.types +++ b/tests/baselines/reference/fatarrowfunctions.types @@ -1,5 +1,4 @@ === tests/cases/compiler/fatarrowfunctions.ts === - function foo(x:any) { >foo : (x: any) => any >x : any diff --git a/tests/baselines/reference/flowInFinally1.js b/tests/baselines/reference/flowInFinally1.js index b6bf494e83232..76769342c0191 100644 --- a/tests/baselines/reference/flowInFinally1.js +++ b/tests/baselines/reference/flowInFinally1.js @@ -1,5 +1,4 @@ //// [flowInFinally1.ts] - class A { constructor() { } method() { } diff --git a/tests/baselines/reference/flowInFinally1.symbols b/tests/baselines/reference/flowInFinally1.symbols index 2ecedaee0257c..dd4a3a88c64b7 100644 --- a/tests/baselines/reference/flowInFinally1.symbols +++ b/tests/baselines/reference/flowInFinally1.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/flowInFinally1.ts === - class A { >A : Symbol(A, Decl(flowInFinally1.ts, 0, 0)) constructor() { } method() { } ->method : Symbol(A.method, Decl(flowInFinally1.ts, 2, 19)) +>method : Symbol(A.method, Decl(flowInFinally1.ts, 1, 19)) } let a: A | null = null; ->a : Symbol(a, Decl(flowInFinally1.ts, 6, 3)) +>a : Symbol(a, Decl(flowInFinally1.ts, 5, 3)) >A : Symbol(A, Decl(flowInFinally1.ts, 0, 0)) try { a = new A(); ->a : Symbol(a, Decl(flowInFinally1.ts, 6, 3)) +>a : Symbol(a, Decl(flowInFinally1.ts, 5, 3)) >A : Symbol(A, Decl(flowInFinally1.ts, 0, 0)) } finally { if (a) { ->a : Symbol(a, Decl(flowInFinally1.ts, 6, 3)) +>a : Symbol(a, Decl(flowInFinally1.ts, 5, 3)) a.method(); ->a.method : Symbol(A.method, Decl(flowInFinally1.ts, 2, 19)) ->a : Symbol(a, Decl(flowInFinally1.ts, 6, 3)) ->method : Symbol(A.method, Decl(flowInFinally1.ts, 2, 19)) +>a.method : Symbol(A.method, Decl(flowInFinally1.ts, 1, 19)) +>a : Symbol(a, Decl(flowInFinally1.ts, 5, 3)) +>method : Symbol(A.method, Decl(flowInFinally1.ts, 1, 19)) } } diff --git a/tests/baselines/reference/flowInFinally1.types b/tests/baselines/reference/flowInFinally1.types index c9cbab6dbd161..c0fba9bf59330 100644 --- a/tests/baselines/reference/flowInFinally1.types +++ b/tests/baselines/reference/flowInFinally1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/flowInFinally1.ts === - class A { >A : A diff --git a/tests/baselines/reference/for-inStatementsArrayErrors.errors.txt b/tests/baselines/reference/for-inStatementsArrayErrors.errors.txt index 03361cfcfab09..a47ea077d95d8 100644 --- a/tests/baselines/reference/for-inStatementsArrayErrors.errors.txt +++ b/tests/baselines/reference/for-inStatementsArrayErrors.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(5,16): error TS7015: Element implicitly has an 'any' type because index expression is not of type 'number'. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(6,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(7,9): error TS2365: Operator '===' cannot be applied to types 'string' and 'number'. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(9,16): error TS2339: Property 'unknownProperty' does not exist on type 'string'. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(13,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'number', but here has type 'string'. -tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(17,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'j' must be of type 'any', but here has type 'string'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(4,16): error TS7015: Element implicitly has an 'any' type because index expression is not of type 'number'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(5,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(6,9): error TS2365: Operator '===' cannot be applied to types 'string' and 'number'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(8,16): error TS2339: Property 'unknownProperty' does not exist on type 'string'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(12,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'number', but here has type 'string'. +tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts(16,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'j' must be of type 'any', but here has type 'string'. ==== tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts (6 errors) ==== - let a: Date[]; for (let x in a) { diff --git a/tests/baselines/reference/for-inStatementsArrayErrors.js b/tests/baselines/reference/for-inStatementsArrayErrors.js index 981a840695ce0..c80f5e4539623 100644 --- a/tests/baselines/reference/for-inStatementsArrayErrors.js +++ b/tests/baselines/reference/for-inStatementsArrayErrors.js @@ -1,5 +1,4 @@ //// [for-inStatementsArrayErrors.ts] - let a: Date[]; for (let x in a) { diff --git a/tests/baselines/reference/for.errors.txt b/tests/baselines/reference/for.errors.txt index d2caefbcdae5a..41ed5765c9a35 100644 --- a/tests/baselines/reference/for.errors.txt +++ b/tests/baselines/reference/for.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/for.ts(30,6): error TS1109: Expression expected. +tests/cases/compiler/for.ts(29,6): error TS1109: Expression expected. ==== tests/cases/compiler/for.ts (1 errors) ==== - for (var i = 0; i < 10; i++) { // ok var x1 = i; } diff --git a/tests/baselines/reference/for.js b/tests/baselines/reference/for.js index 857d42bafdbbc..a77b68d8b6e45 100644 --- a/tests/baselines/reference/for.js +++ b/tests/baselines/reference/for.js @@ -1,5 +1,4 @@ //// [for.ts] - for (var i = 0; i < 10; i++) { // ok var x1 = i; } diff --git a/tests/baselines/reference/forBreakStatements.js b/tests/baselines/reference/forBreakStatements.js index da4fccdfd2ab0..9ed65627c9c6a 100644 --- a/tests/baselines/reference/forBreakStatements.js +++ b/tests/baselines/reference/forBreakStatements.js @@ -1,5 +1,4 @@ //// [forBreakStatements.ts] - for (; ;) { break; } diff --git a/tests/baselines/reference/forBreakStatements.symbols b/tests/baselines/reference/forBreakStatements.symbols index 6d869b45934fa..76db9309a3969 100644 --- a/tests/baselines/reference/forBreakStatements.symbols +++ b/tests/baselines/reference/forBreakStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/forBreakStatements.ts === - for (; ;) { break; } @@ -34,7 +33,7 @@ for (; ;) for (; ;) for (; ;) break SEVEN; EIGHT: for (; ;) { var fn = function () { } ->fn : Symbol(fn, Decl(forBreakStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(forBreakStatements.ts, 33, 7)) break EIGHT; } diff --git a/tests/baselines/reference/forBreakStatements.types b/tests/baselines/reference/forBreakStatements.types index c494f6be30a21..8469a85bd19f7 100644 --- a/tests/baselines/reference/forBreakStatements.types +++ b/tests/baselines/reference/forBreakStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/forBreakStatements.ts === - for (; ;) { break; } diff --git a/tests/baselines/reference/forContinueStatements.js b/tests/baselines/reference/forContinueStatements.js index fc5aa0434b350..34f70bb1fc137 100644 --- a/tests/baselines/reference/forContinueStatements.js +++ b/tests/baselines/reference/forContinueStatements.js @@ -1,5 +1,4 @@ //// [forContinueStatements.ts] - for (; ;) { continue; } diff --git a/tests/baselines/reference/forContinueStatements.symbols b/tests/baselines/reference/forContinueStatements.symbols index 9e0c396acfbe8..e24eb2aaa9252 100644 --- a/tests/baselines/reference/forContinueStatements.symbols +++ b/tests/baselines/reference/forContinueStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/forContinueStatements.ts === - for (; ;) { continue; } @@ -34,7 +33,7 @@ for (; ;) for (; ;) for (; ;) continue SEVEN; EIGHT: for (; ;) { var fn = function () { } ->fn : Symbol(fn, Decl(forContinueStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(forContinueStatements.ts, 33, 7)) continue EIGHT; } diff --git a/tests/baselines/reference/forContinueStatements.types b/tests/baselines/reference/forContinueStatements.types index 0b52bdd5d473e..79b78e83345de 100644 --- a/tests/baselines/reference/forContinueStatements.types +++ b/tests/baselines/reference/forContinueStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/forContinueStatements.ts === - for (; ;) { continue; } diff --git a/tests/baselines/reference/forInBreakStatements.js b/tests/baselines/reference/forInBreakStatements.js index ebbadb31277a1..24b7cc57b8d43 100644 --- a/tests/baselines/reference/forInBreakStatements.js +++ b/tests/baselines/reference/forInBreakStatements.js @@ -1,5 +1,4 @@ //// [forInBreakStatements.ts] - for(var x in {}) { break; } diff --git a/tests/baselines/reference/forInBreakStatements.symbols b/tests/baselines/reference/forInBreakStatements.symbols index 5f48e110835cf..7984edc3fd699 100644 --- a/tests/baselines/reference/forInBreakStatements.symbols +++ b/tests/baselines/reference/forInBreakStatements.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts === - for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) break; } ONE: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) break ONE; } @@ -16,43 +15,43 @@ for(var x in {}) { TWO: THREE: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) break THREE; } FOUR: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) FIVE: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) break FOUR; } } for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) SIX: for(var x in {}) break SIX; ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) } SEVEN: for (var x in {}) for (var x in {}) for (var x in {}) break SEVEN; ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) EIGHT: for (var x in {}){ ->x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) var fn = function () { } ->fn : Symbol(fn, Decl(forInBreakStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(forInBreakStatements.ts, 33, 7)) break EIGHT; } diff --git a/tests/baselines/reference/forInBreakStatements.types b/tests/baselines/reference/forInBreakStatements.types index 4f4b9b3bef98a..bdbec8e9bfeaa 100644 --- a/tests/baselines/reference/forInBreakStatements.types +++ b/tests/baselines/reference/forInBreakStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts === - for(var x in {}) { >x : string >{} : {} diff --git a/tests/baselines/reference/forInContinueStatements.js b/tests/baselines/reference/forInContinueStatements.js index ca530dd5d6cd5..8b036c5972179 100644 --- a/tests/baselines/reference/forInContinueStatements.js +++ b/tests/baselines/reference/forInContinueStatements.js @@ -1,5 +1,4 @@ //// [forInContinueStatements.ts] - for(var x in {}) { continue; } diff --git a/tests/baselines/reference/forInContinueStatements.symbols b/tests/baselines/reference/forInContinueStatements.symbols index a0edea53f3ef3..88129a50d21ce 100644 --- a/tests/baselines/reference/forInContinueStatements.symbols +++ b/tests/baselines/reference/forInContinueStatements.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts === - for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) continue; } ONE: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) continue ONE; } @@ -16,43 +15,43 @@ for(var x in {}) { TWO: THREE: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) continue THREE; } FOUR: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) FIVE: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) continue FOUR; } } for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) SIX: for(var x in {}) continue SIX; ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) } SEVEN: for (var x in {}) for (var x in {}) for (var x in {}) continue SEVEN; ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) EIGHT: for (var x in {}){ ->x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) var fn = function () { } ->fn : Symbol(fn, Decl(forInContinueStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(forInContinueStatements.ts, 33, 7)) continue EIGHT; } diff --git a/tests/baselines/reference/forInContinueStatements.types b/tests/baselines/reference/forInContinueStatements.types index e45cc7985429b..b53d584e13720 100644 --- a/tests/baselines/reference/forInContinueStatements.types +++ b/tests/baselines/reference/forInContinueStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts === - for(var x in {}) { >x : string >{} : {} diff --git a/tests/baselines/reference/forStatements.js b/tests/baselines/reference/forStatements.js index c380185ecf56c..f10a105ecd5d8 100644 --- a/tests/baselines/reference/forStatements.js +++ b/tests/baselines/reference/forStatements.js @@ -1,5 +1,4 @@ //// [forStatements.ts] - interface I { id: number; } diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols index 84cd7dc70d1af..e775d615f3654 100644 --- a/tests/baselines/reference/forStatements.symbols +++ b/tests/baselines/reference/forStatements.symbols @@ -1,146 +1,145 @@ === tests/cases/conformance/statements/forStatements/forStatements.ts === - interface I { >I : Symbol(I, Decl(forStatements.ts, 0, 0)) id: number; ->id : Symbol(I.id, Decl(forStatements.ts, 1, 13)) +>id : Symbol(I.id, Decl(forStatements.ts, 0, 13)) } class C implements I { ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) >I : Symbol(I, Decl(forStatements.ts, 0, 0)) id: number; ->id : Symbol(C.id, Decl(forStatements.ts, 5, 22)) +>id : Symbol(C.id, Decl(forStatements.ts, 4, 22)) } class D{ ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->T : Symbol(T, Decl(forStatements.ts, 9, 8)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>T : Symbol(T, Decl(forStatements.ts, 8, 8)) source: T; ->source : Symbol(D.source, Decl(forStatements.ts, 9, 11)) ->T : Symbol(T, Decl(forStatements.ts, 9, 8)) +>source : Symbol(D.source, Decl(forStatements.ts, 8, 11)) +>T : Symbol(T, Decl(forStatements.ts, 8, 8)) recurse: D; ->recurse : Symbol(D.recurse, Decl(forStatements.ts, 10, 14)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->T : Symbol(T, Decl(forStatements.ts, 9, 8)) +>recurse : Symbol(D.recurse, Decl(forStatements.ts, 9, 14)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>T : Symbol(T, Decl(forStatements.ts, 8, 8)) wrapped: D> ->wrapped : Symbol(D.wrapped, Decl(forStatements.ts, 11, 18)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->T : Symbol(T, Decl(forStatements.ts, 9, 8)) +>wrapped : Symbol(D.wrapped, Decl(forStatements.ts, 10, 18)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>T : Symbol(T, Decl(forStatements.ts, 8, 8)) } function F(x: string): number { return 42; } ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) ->x : Symbol(x, Decl(forStatements.ts, 15, 11)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) +>x : Symbol(x, Decl(forStatements.ts, 14, 11)) module M { ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) export class A { ->A : Symbol(A, Decl(forStatements.ts, 17, 10)) +>A : Symbol(A, Decl(forStatements.ts, 16, 10)) name: string; ->name : Symbol(A.name, Decl(forStatements.ts, 18, 20)) +>name : Symbol(A.name, Decl(forStatements.ts, 17, 20)) } export function F2(x: number): string { return x.toString(); } ->F2 : Symbol(F2, Decl(forStatements.ts, 20, 5)) ->x : Symbol(x, Decl(forStatements.ts, 22, 23)) +>F2 : Symbol(F2, Decl(forStatements.ts, 19, 5)) +>x : Symbol(x, Decl(forStatements.ts, 21, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(forStatements.ts, 22, 23)) +>x : Symbol(x, Decl(forStatements.ts, 21, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } for(var aNumber: number = 9.9;;){} ->aNumber : Symbol(aNumber, Decl(forStatements.ts, 25, 7)) +>aNumber : Symbol(aNumber, Decl(forStatements.ts, 24, 7)) for(var aString: string = 'this is a string';;){} ->aString : Symbol(aString, Decl(forStatements.ts, 26, 7)) +>aString : Symbol(aString, Decl(forStatements.ts, 25, 7)) for(var aDate: Date = new Date(12);;){} ->aDate : Symbol(aDate, Decl(forStatements.ts, 27, 7)) +>aDate : Symbol(aDate, Decl(forStatements.ts, 26, 7)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for(var anObject: Object = new Object();;){} ->anObject : Symbol(anObject, Decl(forStatements.ts, 28, 7)) +>anObject : Symbol(anObject, Decl(forStatements.ts, 27, 7)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for(var anAny: any = null;;){} ->anAny : Symbol(anAny, Decl(forStatements.ts, 30, 7)) +>anAny : Symbol(anAny, Decl(forStatements.ts, 29, 7)) for(var aSecondAny: any = undefined;;){} ->aSecondAny : Symbol(aSecondAny, Decl(forStatements.ts, 31, 7)) +>aSecondAny : Symbol(aSecondAny, Decl(forStatements.ts, 30, 7)) >undefined : Symbol(undefined) for(var aVoid: void = undefined;;){} ->aVoid : Symbol(aVoid, Decl(forStatements.ts, 32, 7)) +>aVoid : Symbol(aVoid, Decl(forStatements.ts, 31, 7)) >undefined : Symbol(undefined) for(var anInterface: I = new C();;){} ->anInterface : Symbol(anInterface, Decl(forStatements.ts, 34, 7)) +>anInterface : Symbol(anInterface, Decl(forStatements.ts, 33, 7)) >I : Symbol(I, Decl(forStatements.ts, 0, 0)) ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) for(var aClass: C = new C();;){} ->aClass : Symbol(aClass, Decl(forStatements.ts, 35, 7)) ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) +>aClass : Symbol(aClass, Decl(forStatements.ts, 34, 7)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) for(var aGenericClass: D = new D();;){} ->aGenericClass : Symbol(aGenericClass, Decl(forStatements.ts, 36, 7)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) ->D : Symbol(D, Decl(forStatements.ts, 7, 1)) +>aGenericClass : Symbol(aGenericClass, Decl(forStatements.ts, 35, 7)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>D : Symbol(D, Decl(forStatements.ts, 6, 1)) for(var anObjectLiteral: I = { id: 12 };;){} ->anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 37, 7)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 36, 7)) >I : Symbol(I, Decl(forStatements.ts, 0, 0)) ->id : Symbol(id, Decl(forStatements.ts, 37, 30)) +>id : Symbol(id, Decl(forStatements.ts, 36, 30)) for(var anOtherObjectLiteral: { id: number } = new C();;){} ->anOtherObjectLiteral : Symbol(anOtherObjectLiteral, Decl(forStatements.ts, 38, 7)) ->id : Symbol(id, Decl(forStatements.ts, 38, 31)) ->C : Symbol(C, Decl(forStatements.ts, 3, 1)) +>anOtherObjectLiteral : Symbol(anOtherObjectLiteral, Decl(forStatements.ts, 37, 7)) +>id : Symbol(id, Decl(forStatements.ts, 37, 31)) +>C : Symbol(C, Decl(forStatements.ts, 2, 1)) for(var aFunction: typeof F = F;;){} ->aFunction : Symbol(aFunction, Decl(forStatements.ts, 40, 7)) ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) +>aFunction : Symbol(aFunction, Decl(forStatements.ts, 39, 7)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) for(var anOtherFunction: (x: string) => number = F;;){} ->anOtherFunction : Symbol(anOtherFunction, Decl(forStatements.ts, 41, 7)) ->x : Symbol(x, Decl(forStatements.ts, 41, 26)) ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) +>anOtherFunction : Symbol(anOtherFunction, Decl(forStatements.ts, 40, 7)) +>x : Symbol(x, Decl(forStatements.ts, 40, 26)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) for(var aLambda: typeof F = (x) => 2;;){} ->aLambda : Symbol(aLambda, Decl(forStatements.ts, 42, 7)) ->F : Symbol(F, Decl(forStatements.ts, 13, 1)) ->x : Symbol(x, Decl(forStatements.ts, 42, 29)) +>aLambda : Symbol(aLambda, Decl(forStatements.ts, 41, 7)) +>F : Symbol(F, Decl(forStatements.ts, 12, 1)) +>x : Symbol(x, Decl(forStatements.ts, 41, 29)) for(var aModule: typeof M = M;;){} ->aModule : Symbol(aModule, Decl(forStatements.ts, 44, 7)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) +>aModule : Symbol(aModule, Decl(forStatements.ts, 43, 7)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) for(var aClassInModule: M.A = new M.A();;){} ->aClassInModule : Symbol(aClassInModule, Decl(forStatements.ts, 45, 7)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) ->A : Symbol(M.A, Decl(forStatements.ts, 17, 10)) ->M.A : Symbol(M.A, Decl(forStatements.ts, 17, 10)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) ->A : Symbol(M.A, Decl(forStatements.ts, 17, 10)) +>aClassInModule : Symbol(aClassInModule, Decl(forStatements.ts, 44, 7)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>A : Symbol(M.A, Decl(forStatements.ts, 16, 10)) +>M.A : Symbol(M.A, Decl(forStatements.ts, 16, 10)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>A : Symbol(M.A, Decl(forStatements.ts, 16, 10)) for(var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';;){} ->aFunctionInModule : Symbol(aFunctionInModule, Decl(forStatements.ts, 46, 7)) ->M.F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5)) ->M : Symbol(M, Decl(forStatements.ts, 15, 44)) ->F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5)) ->x : Symbol(x, Decl(forStatements.ts, 46, 42)) +>aFunctionInModule : Symbol(aFunctionInModule, Decl(forStatements.ts, 45, 7)) +>M.F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5)) +>M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5)) +>x : Symbol(x, Decl(forStatements.ts, 45, 42)) diff --git a/tests/baselines/reference/forStatements.types b/tests/baselines/reference/forStatements.types index a6ae6ea9aa5f2..7c467d31847e7 100644 --- a/tests/baselines/reference/forStatements.types +++ b/tests/baselines/reference/forStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/forStatements/forStatements.ts === - interface I { >I : I diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt index f1869ae7fca29..53ecb88363df4 100644 --- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt +++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt @@ -1,19 +1,18 @@ -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'number'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'string'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'C'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'D'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(37,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'typeof M'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(41,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C2'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(44,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type 'number[]'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(48,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type '(C | D)[]'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(51,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr2' must be of type 'D[]', but here has type 'D[]'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(54,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'm' must be of type 'typeof M', but here has type 'typeof A'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(32,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'number'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'string'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'C'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'D'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'typeof M'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(39,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C2'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(43,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(46,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type 'number[]'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type '(C | D)[]'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(50,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr2' must be of type 'D[]', but here has type 'D[]'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(53,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'm' must be of type 'typeof M', but here has type 'typeof A'. ==== tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts (12 errors) ==== - interface I { id: number; } diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js index 27284f8b27252..e6404a73c602f 100644 --- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js +++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js @@ -1,5 +1,4 @@ //// [forStatementsMultipleInvalidDecl.ts] - interface I { id: number; } diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.js b/tests/baselines/reference/forStatementsMultipleValidDecl.js index 6913894a15f5d..e95e37d63ac5c 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.js +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.js @@ -1,5 +1,4 @@ //// [forStatementsMultipleValidDecl.ts] - // all expected to be valid for (var x: number; ;) { } diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols index 89e36c4a8f5dd..efb1e57697505 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols @@ -1,111 +1,110 @@ === tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts === - // all expected to be valid for (var x: number; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8)) for (var x = 2; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8)) for (var x = undefined; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8)) >undefined : Symbol(undefined) // new declaration space, making redeclaring x as a string valid function declSpace() { ->declSpace : Symbol(declSpace, Decl(forStatementsMultipleValidDecl.ts, 6, 38)) +>declSpace : Symbol(declSpace, Decl(forStatementsMultipleValidDecl.ts, 5, 38)) for (var x = 'this is a string'; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 9, 12)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 8, 12)) } interface Point { x: number; y: number; } ->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1)) ->x : Symbol(Point.x, Decl(forStatementsMultipleValidDecl.ts, 11, 17)) ->y : Symbol(Point.y, Decl(forStatementsMultipleValidDecl.ts, 11, 28)) +>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1)) +>x : Symbol(Point.x, Decl(forStatementsMultipleValidDecl.ts, 10, 17)) +>y : Symbol(Point.y, Decl(forStatementsMultipleValidDecl.ts, 10, 28)) for (var p: Point; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1)) for (var p = { x: 1, y: 2 }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 14)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 20)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 13, 14)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 13, 20)) for (var p: Point = { x: 0, y: undefined }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 21)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 27)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 21)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 27)) >undefined : Symbol(undefined) for (var p = { x: 1, y: undefined }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 14)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 20)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 14)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 20)) >undefined : Symbol(undefined) for (var p: { x: number; y: number; } = { x: 1, y: 2 }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 13)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 24)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 41)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 47)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 13)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 24)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 41)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 47)) for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 15)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 26)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 41)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 47)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 15)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 26)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 41)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 47)) >undefined : Symbol(undefined) for (var p: typeof p; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) for (var fn = function (s: string) { return 42; }; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 24)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 20, 24)) for (var fn = (s: string) => 3; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 22, 15)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 15)) for (var fn: (s: string) => number; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 23, 14)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 22, 14)) for (var fn: { (s: string): number }; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 24, 16)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 23, 16)) for (var fn = <(s: string) => number> null; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 25, 16)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 24, 16)) for (var fn: typeof fn; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) for (var a: string[]; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) for (var a = ['a', 'b']; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) for (var a = []; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) for (var a: string[] = []; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) for (var a = new Array(); ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for (var a: typeof a; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.types b/tests/baselines/reference/forStatementsMultipleValidDecl.types index f40f4bbbc3ce8..d0950d67924f1 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.types +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts === - // all expected to be valid for (var x: number; ;) { } diff --git a/tests/baselines/reference/functionCalls.errors.txt b/tests/baselines/reference/functionCalls.errors.txt index dc1417cdc983e..85e7587677901 100644 --- a/tests/baselines/reference/functionCalls.errors.txt +++ b/tests/baselines/reference/functionCalls.errors.txt @@ -1,16 +1,15 @@ +tests/cases/conformance/expressions/functionCalls/functionCalls.ts(8,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(9,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(10,1): error TS2347: Untyped function calls may not accept type arguments. -tests/cases/conformance/expressions/functionCalls/functionCalls.ts(11,1): error TS2347: Untyped function calls may not accept type arguments. +tests/cases/conformance/expressions/functionCalls/functionCalls.ts(25,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(26,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(27,1): error TS2347: Untyped function calls may not accept type arguments. -tests/cases/conformance/expressions/functionCalls/functionCalls.ts(28,1): error TS2347: Untyped function calls may not accept type arguments. +tests/cases/conformance/expressions/functionCalls/functionCalls.ts(32,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(33,1): error TS2347: Untyped function calls may not accept type arguments. tests/cases/conformance/expressions/functionCalls/functionCalls.ts(34,1): error TS2347: Untyped function calls may not accept type arguments. -tests/cases/conformance/expressions/functionCalls/functionCalls.ts(35,1): error TS2347: Untyped function calls may not accept type arguments. ==== tests/cases/conformance/expressions/functionCalls/functionCalls.ts (9 errors) ==== - // Invoke function call on value of type 'any' with no type arguments var anyVar: any; anyVar(0); diff --git a/tests/baselines/reference/functionCalls.js b/tests/baselines/reference/functionCalls.js index e7b80fffdd84d..bba73092b46a2 100644 --- a/tests/baselines/reference/functionCalls.js +++ b/tests/baselines/reference/functionCalls.js @@ -1,5 +1,4 @@ //// [functionCalls.ts] - // Invoke function call on value of type 'any' with no type arguments var anyVar: any; anyVar(0); diff --git a/tests/baselines/reference/functionImplementationErrors.errors.txt b/tests/baselines/reference/functionImplementationErrors.errors.txt index 224ebc7c08ef1..5ed54e044d288 100644 --- a/tests/baselines/reference/functionImplementationErrors.errors.txt +++ b/tests/baselines/reference/functionImplementationErrors.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/functions/functionImplementationErrors.ts(26,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. -tests/cases/conformance/functions/functionImplementationErrors.ts(31,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. -tests/cases/conformance/functions/functionImplementationErrors.ts(36,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. +tests/cases/conformance/functions/functionImplementationErrors.ts(25,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/conformance/functions/functionImplementationErrors.ts(30,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. +tests/cases/conformance/functions/functionImplementationErrors.ts(35,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. ==== tests/cases/conformance/functions/functionImplementationErrors.ts (3 errors) ==== - // FunctionExpression with no return type annotation with multiple return statements with unrelated types var f1 = function () { return ''; diff --git a/tests/baselines/reference/functionImplementationErrors.js b/tests/baselines/reference/functionImplementationErrors.js index e227693b38602..533aa9e9d27a0 100644 --- a/tests/baselines/reference/functionImplementationErrors.js +++ b/tests/baselines/reference/functionImplementationErrors.js @@ -1,5 +1,4 @@ //// [functionImplementationErrors.ts] - // FunctionExpression with no return type annotation with multiple return statements with unrelated types var f1 = function () { return ''; diff --git a/tests/baselines/reference/functionImplementations.js b/tests/baselines/reference/functionImplementations.js index 994ff36da56f1..bc1a83aa16a61 100644 --- a/tests/baselines/reference/functionImplementations.js +++ b/tests/baselines/reference/functionImplementations.js @@ -1,5 +1,4 @@ //// [functionImplementations.ts] - // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); diff --git a/tests/baselines/reference/functionImplementations.symbols b/tests/baselines/reference/functionImplementations.symbols index 1d8c5b2618b72..4f2f814ccefb5 100644 --- a/tests/baselines/reference/functionImplementations.symbols +++ b/tests/baselines/reference/functionImplementations.symbols @@ -1,110 +1,109 @@ === tests/cases/conformance/functions/functionImplementations.ts === - // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); ->v : Symbol(v, Decl(functionImplementations.ts, 2, 3)) +>v : Symbol(v, Decl(functionImplementations.ts, 1, 3)) // FunctionExpression f with no return type annotation and directly references f in its body returns any var a: any = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 5, 12)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 4, 12)) return f; ->f : Symbol(f, Decl(functionImplementations.ts, 5, 12)) +>f : Symbol(f, Decl(functionImplementations.ts, 4, 12)) }; var a: any = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 8, 12)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 7, 12)) return f(); ->f : Symbol(f, Decl(functionImplementations.ts, 8, 12)) +>f : Symbol(f, Decl(functionImplementations.ts, 7, 12)) }; // FunctionExpression f with no return type annotation and indirectly references f in its body returns any var a: any = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 13, 12)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 12, 12)) var x = f; ->x : Symbol(x, Decl(functionImplementations.ts, 14, 7)) ->f : Symbol(f, Decl(functionImplementations.ts, 13, 12)) +>x : Symbol(x, Decl(functionImplementations.ts, 13, 7)) +>f : Symbol(f, Decl(functionImplementations.ts, 12, 12)) return x; ->x : Symbol(x, Decl(functionImplementations.ts, 14, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 13, 7)) }; // Two mutually recursive function implementations with no return type annotations function rec1() { ->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2)) +>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2)) return rec2(); ->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1)) +>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1)) } function rec2() { ->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1)) +>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1)) return rec1(); ->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2)) +>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2)) } var a = rec1(); ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2)) var a = rec2(); ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1)) // Two mutually recursive function implementations with return type annotation in one function rec3(): number { ->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15)) +>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15)) return rec4(); ->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1)) +>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1)) } function rec4() { ->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1)) +>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1)) return rec3(); ->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15)) +>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15)) } var n: number; ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) var n = rec3(); ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) ->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15)) var n = rec4(); ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) ->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1)) // FunctionExpression with no return type annotation and returns a number var n = function () { ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) return 3; } (); // FunctionExpression with no return type annotation and returns null var nu = null; ->nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3)) +>nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3)) var nu = function () { ->nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3)) +>nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3)) return null; } (); // FunctionExpression with no return type annotation and returns undefined var un = undefined; ->un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3)) +>un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3)) >undefined : Symbol(undefined) var un = function () { ->un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3)) +>un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3)) return undefined; >undefined : Symbol(undefined) @@ -113,31 +112,31 @@ var un = function () { // FunctionExpression with no return type annotation and returns a type parameter type var n = function (x: T) { ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) ->T : Symbol(T, Decl(functionImplementations.ts, 57, 18)) ->x : Symbol(x, Decl(functionImplementations.ts, 57, 21)) ->T : Symbol(T, Decl(functionImplementations.ts, 57, 18)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>T : Symbol(T, Decl(functionImplementations.ts, 56, 18)) +>x : Symbol(x, Decl(functionImplementations.ts, 56, 21)) +>T : Symbol(T, Decl(functionImplementations.ts, 56, 18)) return x; ->x : Symbol(x, Decl(functionImplementations.ts, 57, 21)) +>x : Symbol(x, Decl(functionImplementations.ts, 56, 21)) } (4); // FunctionExpression with no return type annotation and returns a constrained type parameter type var n = function (x: T) { ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) ->T : Symbol(T, Decl(functionImplementations.ts, 62, 18)) ->x : Symbol(x, Decl(functionImplementations.ts, 62, 32)) ->T : Symbol(T, Decl(functionImplementations.ts, 62, 18)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>T : Symbol(T, Decl(functionImplementations.ts, 61, 18)) +>x : Symbol(x, Decl(functionImplementations.ts, 61, 32)) +>T : Symbol(T, Decl(functionImplementations.ts, 61, 18)) return x; ->x : Symbol(x, Decl(functionImplementations.ts, 62, 32)) +>x : Symbol(x, Decl(functionImplementations.ts, 61, 32)) } (4); // FunctionExpression with no return type annotation with multiple return statements with identical types var n = function () { ->n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) return 3; return 5; @@ -149,36 +148,36 @@ var n = function () { // A compile - time error occurs if no return statement expression has a type that is a supertype of each of the others. // FunctionExpression with no return type annotation with multiple return statements with subtype relation between returns class Base { private m; } ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->m : Symbol(Base.m, Decl(functionImplementations.ts, 77, 12)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>m : Symbol(Base.m, Decl(functionImplementations.ts, 76, 12)) class Derived extends Base { private q; } ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->q : Symbol(Derived.q, Decl(functionImplementations.ts, 78, 28)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>q : Symbol(Derived.q, Decl(functionImplementations.ts, 77, 28)) var b: Base; ->b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3)) ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) var b = function () { ->b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3)) +>b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3)) return new Base(); return new Derived(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) } (); // FunctionExpression with no return type annotation with multiple return statements with one a recursive call var a = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 85, 7)) +>a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 84, 7)) return new Base(); return new Derived(); return f(); // ? ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) ->f : Symbol(f, Decl(functionImplementations.ts, 85, 7)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) +>f : Symbol(f, Decl(functionImplementations.ts, 84, 7)) } (); @@ -193,59 +192,59 @@ undefined === function (): number { // Type of 'this' in function implementation is 'any' function thisFunc() { ->thisFunc : Symbol(thisFunc, Decl(functionImplementations.ts, 92, 2)) +>thisFunc : Symbol(thisFunc, Decl(functionImplementations.ts, 91, 2)) var x = this; ->x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 95, 7), Decl(functionImplementations.ts, 96, 7)) var x: any; ->x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 95, 7), Decl(functionImplementations.ts, 96, 7)) } // Function signature with optional parameter, no type annotation and initializer has initializer's type function opt1(n = 4) { ->opt1 : Symbol(opt1, Decl(functionImplementations.ts, 98, 1)) ->n : Symbol(n, Decl(functionImplementations.ts, 101, 14)) +>opt1 : Symbol(opt1, Decl(functionImplementations.ts, 97, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 100, 14)) var m = n; ->m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7)) ->n : Symbol(n, Decl(functionImplementations.ts, 101, 14)) +>m : Symbol(m, Decl(functionImplementations.ts, 101, 7), Decl(functionImplementations.ts, 102, 7)) +>n : Symbol(n, Decl(functionImplementations.ts, 100, 14)) var m: number; ->m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7)) +>m : Symbol(m, Decl(functionImplementations.ts, 101, 7), Decl(functionImplementations.ts, 102, 7)) } // Function signature with optional parameter, no type annotation and initializer has initializer's widened type function opt2(n = { x: null, y: undefined }) { ->opt2 : Symbol(opt2, Decl(functionImplementations.ts, 104, 1)) ->n : Symbol(n, Decl(functionImplementations.ts, 107, 14)) ->x : Symbol(x, Decl(functionImplementations.ts, 107, 19)) ->y : Symbol(y, Decl(functionImplementations.ts, 107, 28)) +>opt2 : Symbol(opt2, Decl(functionImplementations.ts, 103, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 106, 14)) +>x : Symbol(x, Decl(functionImplementations.ts, 106, 19)) +>y : Symbol(y, Decl(functionImplementations.ts, 106, 28)) >undefined : Symbol(undefined) var m = n; ->m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7)) ->n : Symbol(n, Decl(functionImplementations.ts, 107, 14)) +>m : Symbol(m, Decl(functionImplementations.ts, 107, 7), Decl(functionImplementations.ts, 108, 7)) +>n : Symbol(n, Decl(functionImplementations.ts, 106, 14)) var m: { x: any; y: any }; ->m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7)) ->x : Symbol(x, Decl(functionImplementations.ts, 109, 12)) ->y : Symbol(y, Decl(functionImplementations.ts, 109, 20)) +>m : Symbol(m, Decl(functionImplementations.ts, 107, 7), Decl(functionImplementations.ts, 108, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 108, 12)) +>y : Symbol(y, Decl(functionImplementations.ts, 108, 20)) } // Function signature with initializer referencing other parameter to the left function opt3(n: number, m = n) { ->opt3 : Symbol(opt3, Decl(functionImplementations.ts, 110, 1)) ->n : Symbol(n, Decl(functionImplementations.ts, 113, 14)) ->m : Symbol(m, Decl(functionImplementations.ts, 113, 24)) ->n : Symbol(n, Decl(functionImplementations.ts, 113, 14)) +>opt3 : Symbol(opt3, Decl(functionImplementations.ts, 109, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 112, 14)) +>m : Symbol(m, Decl(functionImplementations.ts, 112, 24)) +>n : Symbol(n, Decl(functionImplementations.ts, 112, 14)) var y = m; ->y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7)) ->m : Symbol(m, Decl(functionImplementations.ts, 113, 24)) +>y : Symbol(y, Decl(functionImplementations.ts, 113, 7), Decl(functionImplementations.ts, 114, 7)) +>m : Symbol(m, Decl(functionImplementations.ts, 112, 24)) var y: number; ->y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7)) +>y : Symbol(y, Decl(functionImplementations.ts, 113, 7), Decl(functionImplementations.ts, 114, 7)) } // Function signature with optional parameter has correct codegen @@ -253,93 +252,93 @@ function opt3(n: number, m = n) { // FunctionExpression with non -void return type annotation return with no expression function f6(): number { ->f6 : Symbol(f6, Decl(functionImplementations.ts, 116, 1)) +>f6 : Symbol(f6, Decl(functionImplementations.ts, 115, 1)) return; } class Derived2 extends Base { private r: string; } ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) ->r : Symbol(Derived2.r, Decl(functionImplementations.ts, 126, 29)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>r : Symbol(Derived2.r, Decl(functionImplementations.ts, 125, 29)) class AnotherClass { private x } ->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50)) ->x : Symbol(AnotherClass.x, Decl(functionImplementations.ts, 127, 20)) +>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50)) +>x : Symbol(AnotherClass.x, Decl(functionImplementations.ts, 126, 20)) // if f is a contextually typed function expression, the inferred return type is the union type // of the types of the return statement expressions in the function body, // ignoring return statements with no expressions. var f7: (x: number) => string | number = x => { // should be (x: number) => number | string ->f7 : Symbol(f7, Decl(functionImplementations.ts, 131, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 131, 9)) ->x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) +>f7 : Symbol(f7, Decl(functionImplementations.ts, 130, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 9)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) if (x < 0) { return x; } ->x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) ->x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) return x.toString(); >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) +>x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } var f8: (x: number) => any = x => { // should be (x: number) => Base ->f8 : Symbol(f8, Decl(functionImplementations.ts, 135, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 135, 9)) ->x : Symbol(x, Decl(functionImplementations.ts, 135, 28)) +>f8 : Symbol(f8, Decl(functionImplementations.ts, 134, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 134, 9)) +>x : Symbol(x, Decl(functionImplementations.ts, 134, 28)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) return new Derived2(); ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) } var f9: (x: number) => any = x => { // should be (x: number) => Base ->f9 : Symbol(f9, Decl(functionImplementations.ts, 139, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 139, 9)) ->x : Symbol(x, Decl(functionImplementations.ts, 139, 28)) +>f9 : Symbol(f9, Decl(functionImplementations.ts, 138, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 138, 9)) +>x : Symbol(x, Decl(functionImplementations.ts, 138, 28)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) return new Derived(); ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) return new Derived2(); ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) } var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1 ->f10 : Symbol(f10, Decl(functionImplementations.ts, 144, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 144, 10)) ->x : Symbol(x, Decl(functionImplementations.ts, 144, 29)) +>f10 : Symbol(f10, Decl(functionImplementations.ts, 143, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 143, 10)) +>x : Symbol(x, Decl(functionImplementations.ts, 143, 29)) return new Derived(); ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) return new Derived2(); ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) } var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass ->f11 : Symbol(f11, Decl(functionImplementations.ts, 148, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 148, 10)) ->x : Symbol(x, Decl(functionImplementations.ts, 148, 29)) +>f11 : Symbol(f11, Decl(functionImplementations.ts, 147, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 147, 10)) +>x : Symbol(x, Decl(functionImplementations.ts, 147, 29)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) return new AnotherClass(); ->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50)) +>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50)) } var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass ->f12 : Symbol(f12, Decl(functionImplementations.ts, 152, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 152, 10)) ->x : Symbol(x, Decl(functionImplementations.ts, 152, 29)) +>f12 : Symbol(f12, Decl(functionImplementations.ts, 151, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 151, 10)) +>x : Symbol(x, Decl(functionImplementations.ts, 151, 29)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) return; // should be ignored return new AnotherClass(); ->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50)) +>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50)) } diff --git a/tests/baselines/reference/functionImplementations.types b/tests/baselines/reference/functionImplementations.types index d81b02598bdf0..43ed3fe24fe75 100644 --- a/tests/baselines/reference/functionImplementations.types +++ b/tests/baselines/reference/functionImplementations.types @@ -1,5 +1,4 @@ === tests/cases/conformance/functions/functionImplementations.ts === - // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); >v : void diff --git a/tests/baselines/reference/functionOverloads12.js b/tests/baselines/reference/functionOverloads12.js index 8d834e8180f60..4681e43ee5b26 100644 --- a/tests/baselines/reference/functionOverloads12.js +++ b/tests/baselines/reference/functionOverloads12.js @@ -1,5 +1,4 @@ //// [functionOverloads12.ts] - function foo():string; function foo():number; function foo():any { if (true) return ""; else return 0;} diff --git a/tests/baselines/reference/functionOverloads12.symbols b/tests/baselines/reference/functionOverloads12.symbols index 4744f98c9f2ac..583e7f5c04572 100644 --- a/tests/baselines/reference/functionOverloads12.symbols +++ b/tests/baselines/reference/functionOverloads12.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/functionOverloads12.ts === - function foo():string; ->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22)) +>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22)) function foo():number; ->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22)) +>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22)) function foo():any { if (true) return ""; else return 0;} ->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22)) +>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22)) diff --git a/tests/baselines/reference/functionOverloads12.types b/tests/baselines/reference/functionOverloads12.types index d29f6262844f9..48f39b786f5c2 100644 --- a/tests/baselines/reference/functionOverloads12.types +++ b/tests/baselines/reference/functionOverloads12.types @@ -1,5 +1,4 @@ === tests/cases/compiler/functionOverloads12.ts === - function foo():string; >foo : { (): string; (): number; } diff --git a/tests/baselines/reference/functionReturn.js b/tests/baselines/reference/functionReturn.js index 42d0de5fd7c29..c433eec190d72 100644 --- a/tests/baselines/reference/functionReturn.js +++ b/tests/baselines/reference/functionReturn.js @@ -1,5 +1,4 @@ //// [functionReturn.ts] - function f0(): void { } function f1() { var n: any = f0(); diff --git a/tests/baselines/reference/functionReturn.symbols b/tests/baselines/reference/functionReturn.symbols index 630e435635be1..9c6b794b3d005 100644 --- a/tests/baselines/reference/functionReturn.symbols +++ b/tests/baselines/reference/functionReturn.symbols @@ -1,29 +1,28 @@ === tests/cases/compiler/functionReturn.ts === - function f0(): void { } >f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0)) function f1() { ->f1 : Symbol(f1, Decl(functionReturn.ts, 1, 23)) +>f1 : Symbol(f1, Decl(functionReturn.ts, 0, 23)) var n: any = f0(); ->n : Symbol(n, Decl(functionReturn.ts, 3, 7)) +>n : Symbol(n, Decl(functionReturn.ts, 2, 7)) >f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0)) } function f2(): any { } ->f2 : Symbol(f2, Decl(functionReturn.ts, 4, 1)) +>f2 : Symbol(f2, Decl(functionReturn.ts, 3, 1)) function f3(): string { return; } ->f3 : Symbol(f3, Decl(functionReturn.ts, 5, 22)) +>f3 : Symbol(f3, Decl(functionReturn.ts, 4, 22)) function f4(): string { ->f4 : Symbol(f4, Decl(functionReturn.ts, 6, 33)) +>f4 : Symbol(f4, Decl(functionReturn.ts, 5, 33)) return ''; return; } function f5(): string { ->f5 : Symbol(f5, Decl(functionReturn.ts, 10, 1)) +>f5 : Symbol(f5, Decl(functionReturn.ts, 9, 1)) return ''; return undefined; diff --git a/tests/baselines/reference/functionReturn.types b/tests/baselines/reference/functionReturn.types index 7b8f58de2a891..56cdc534c93c6 100644 --- a/tests/baselines/reference/functionReturn.types +++ b/tests/baselines/reference/functionReturn.types @@ -1,5 +1,4 @@ === tests/cases/compiler/functionReturn.ts === - function f0(): void { } >f0 : () => void diff --git a/tests/baselines/reference/functionTypesLackingReturnTypes.errors.txt b/tests/baselines/reference/functionTypesLackingReturnTypes.errors.txt index 84ec6ff1ba5a5..e99fb3bcf0ddd 100644 --- a/tests/baselines/reference/functionTypesLackingReturnTypes.errors.txt +++ b/tests/baselines/reference/functionTypesLackingReturnTypes.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/functionTypesLackingReturnTypes.ts(3,17): error TS1005: '=>' expected. -tests/cases/compiler/functionTypesLackingReturnTypes.ts(7,9): error TS2304: Cannot find name 'param'. +tests/cases/compiler/functionTypesLackingReturnTypes.ts(2,17): error TS1005: '=>' expected. +tests/cases/compiler/functionTypesLackingReturnTypes.ts(6,9): error TS2304: Cannot find name 'param'. ==== tests/cases/compiler/functionTypesLackingReturnTypes.ts (2 errors) ==== - // Error (no '=>') function f(x: ()) { ~ diff --git a/tests/baselines/reference/functionTypesLackingReturnTypes.js b/tests/baselines/reference/functionTypesLackingReturnTypes.js index 10b447a838fcc..d12f5ebfe175c 100644 --- a/tests/baselines/reference/functionTypesLackingReturnTypes.js +++ b/tests/baselines/reference/functionTypesLackingReturnTypes.js @@ -1,5 +1,4 @@ //// [functionTypesLackingReturnTypes.ts] - // Error (no '=>') function f(x: ()) { } diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.js b/tests/baselines/reference/functionWithMultipleReturnStatements.js index d44c37ebbf0e7..347a05d0f3355 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements.js +++ b/tests/baselines/reference/functionWithMultipleReturnStatements.js @@ -1,5 +1,4 @@ //// [functionWithMultipleReturnStatements.ts] - // return type of a function with multiple returns is the BCT of each return statement // it is an error if there is no single BCT, these are error cases diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.symbols b/tests/baselines/reference/functionWithMultipleReturnStatements.symbols index a33db45964066..c1f9d9157bf93 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements.symbols +++ b/tests/baselines/reference/functionWithMultipleReturnStatements.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts === - // return type of a function with multiple returns is the BCT of each return statement // it is an error if there is no single BCT, these are error cases @@ -14,7 +13,7 @@ function f1() { } function f2() { ->f2 : Symbol(f2, Decl(functionWithMultipleReturnStatements.ts, 10, 1)) +>f2 : Symbol(f2, Decl(functionWithMultipleReturnStatements.ts, 9, 1)) if (true) { return 1; @@ -26,26 +25,26 @@ function f2() { } function f3() { ->f3 : Symbol(f3, Decl(functionWithMultipleReturnStatements.ts, 20, 1)) +>f3 : Symbol(f3, Decl(functionWithMultipleReturnStatements.ts, 19, 1)) try { return 1; } catch (e) { ->e : Symbol(e, Decl(functionWithMultipleReturnStatements.ts, 26, 11)) +>e : Symbol(e, Decl(functionWithMultipleReturnStatements.ts, 25, 11)) return ''; } } function f4() { ->f4 : Symbol(f4, Decl(functionWithMultipleReturnStatements.ts, 29, 1)) +>f4 : Symbol(f4, Decl(functionWithMultipleReturnStatements.ts, 28, 1)) try { return 1; } catch (e) { ->e : Symbol(e, Decl(functionWithMultipleReturnStatements.ts, 35, 11)) +>e : Symbol(e, Decl(functionWithMultipleReturnStatements.ts, 34, 11)) } finally { @@ -54,50 +53,50 @@ function f4() { } function f5() { ->f5 : Symbol(f5, Decl(functionWithMultipleReturnStatements.ts, 41, 1)) +>f5 : Symbol(f5, Decl(functionWithMultipleReturnStatements.ts, 40, 1)) return 1; return ''; } function f6(x: T, y:U) { ->f6 : Symbol(f6, Decl(functionWithMultipleReturnStatements.ts, 46, 1)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 48, 12)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 48, 14)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 48, 18)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 48, 12)) ->y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 48, 23)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 48, 14)) +>f6 : Symbol(f6, Decl(functionWithMultipleReturnStatements.ts, 45, 1)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 47, 12)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 47, 14)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 47, 18)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 47, 12)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 47, 23)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 47, 14)) if (true) { return x; ->x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 48, 18)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 47, 18)) } else { return y; ->y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 48, 23)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 47, 23)) } } function f8(x: T, y: U) { ->f8 : Symbol(f8, Decl(functionWithMultipleReturnStatements.ts, 54, 1)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 56, 12)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 56, 24)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 56, 24)) ->V : Symbol(V, Decl(functionWithMultipleReturnStatements.ts, 56, 37)) ->V : Symbol(V, Decl(functionWithMultipleReturnStatements.ts, 56, 37)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 56, 41)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 56, 12)) ->y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 56, 46)) ->U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 56, 24)) +>f8 : Symbol(f8, Decl(functionWithMultipleReturnStatements.ts, 53, 1)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 55, 12)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 55, 24)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 55, 24)) +>V : Symbol(V, Decl(functionWithMultipleReturnStatements.ts, 55, 37)) +>V : Symbol(V, Decl(functionWithMultipleReturnStatements.ts, 55, 37)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 55, 41)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements.ts, 55, 12)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 55, 46)) +>U : Symbol(U, Decl(functionWithMultipleReturnStatements.ts, 55, 24)) if (true) { return x; ->x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 56, 41)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements.ts, 55, 41)) } else { return y; ->y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 56, 46)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements.ts, 55, 46)) } } diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.types b/tests/baselines/reference/functionWithMultipleReturnStatements.types index fec29e5a01be1..8d2a4985d98b1 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements.types +++ b/tests/baselines/reference/functionWithMultipleReturnStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts === - // return type of a function with multiple returns is the BCT of each return statement // it is an error if there is no single BCT, these are error cases diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.js b/tests/baselines/reference/functionWithMultipleReturnStatements2.js index efee5816fb668..4674c6db953e1 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.js +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.js @@ -1,5 +1,4 @@ //// [functionWithMultipleReturnStatements2.ts] - // return type of a function with multiple returns is the BCT of each return statement // no errors expected here diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.symbols b/tests/baselines/reference/functionWithMultipleReturnStatements2.symbols index 39cad6bc41488..c4aa66638031e 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.symbols +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts === - // return type of a function with multiple returns is the BCT of each return statement // no errors expected here @@ -14,7 +13,7 @@ function f1() { } function f2() { ->f2 : Symbol(f2, Decl(functionWithMultipleReturnStatements2.ts, 10, 1)) +>f2 : Symbol(f2, Decl(functionWithMultipleReturnStatements2.ts, 9, 1)) if (true) { return 1; @@ -26,13 +25,13 @@ function f2() { } function f4() { ->f4 : Symbol(f4, Decl(functionWithMultipleReturnStatements2.ts, 20, 1)) +>f4 : Symbol(f4, Decl(functionWithMultipleReturnStatements2.ts, 19, 1)) try { return 1; } catch (e) { ->e : Symbol(e, Decl(functionWithMultipleReturnStatements2.ts, 26, 11)) +>e : Symbol(e, Decl(functionWithMultipleReturnStatements2.ts, 25, 11)) return undefined; >undefined : Symbol(undefined) @@ -43,7 +42,7 @@ function f4() { } function f5() { ->f5 : Symbol(f5, Decl(functionWithMultipleReturnStatements2.ts, 32, 1)) +>f5 : Symbol(f5, Decl(functionWithMultipleReturnStatements2.ts, 31, 1)) return 1; return new Object(); @@ -51,14 +50,14 @@ function f5() { } function f6(x: T) { ->f6 : Symbol(f6, Decl(functionWithMultipleReturnStatements2.ts, 37, 1)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements2.ts, 39, 12)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 39, 15)) ->T : Symbol(T, Decl(functionWithMultipleReturnStatements2.ts, 39, 12)) +>f6 : Symbol(f6, Decl(functionWithMultipleReturnStatements2.ts, 36, 1)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements2.ts, 38, 12)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 38, 15)) +>T : Symbol(T, Decl(functionWithMultipleReturnStatements2.ts, 38, 12)) if (true) { return x; ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 39, 15)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 38, 15)) } else { return null; @@ -74,69 +73,69 @@ function f6(x: T) { //} var a: { x: number; y?: number }; ->a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 55, 8)) ->y : Symbol(y, Decl(functionWithMultipleReturnStatements2.ts, 55, 19)) +>a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 54, 3)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 54, 8)) +>y : Symbol(y, Decl(functionWithMultipleReturnStatements2.ts, 54, 19)) var b: { x: number; z?: number }; ->b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 56, 3)) ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 56, 8)) ->z : Symbol(z, Decl(functionWithMultipleReturnStatements2.ts, 56, 19)) +>b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 55, 8)) +>z : Symbol(z, Decl(functionWithMultipleReturnStatements2.ts, 55, 19)) // returns typeof a function f9() { ->f9 : Symbol(f9, Decl(functionWithMultipleReturnStatements2.ts, 56, 33)) +>f9 : Symbol(f9, Decl(functionWithMultipleReturnStatements2.ts, 55, 33)) if (true) { return a; ->a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) +>a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 54, 3)) } else { return b; ->b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 56, 3)) +>b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) } } // returns typeof b function f10() { ->f10 : Symbol(f10, Decl(functionWithMultipleReturnStatements2.ts, 64, 1)) +>f10 : Symbol(f10, Decl(functionWithMultipleReturnStatements2.ts, 63, 1)) if (true) { return b; ->b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 56, 3)) +>b : Symbol(b, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) } else { return a; ->a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 55, 3)) +>a : Symbol(a, Decl(functionWithMultipleReturnStatements2.ts, 54, 3)) } } // returns number => void function f11() { ->f11 : Symbol(f11, Decl(functionWithMultipleReturnStatements2.ts, 73, 1)) +>f11 : Symbol(f11, Decl(functionWithMultipleReturnStatements2.ts, 72, 1)) if (true) { return (x: number) => { } ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 78, 16)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 77, 16)) } else { return (x: Object) => { } ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 80, 16)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 79, 16)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } } // returns Object => void function f12() { ->f12 : Symbol(f12, Decl(functionWithMultipleReturnStatements2.ts, 82, 1)) +>f12 : Symbol(f12, Decl(functionWithMultipleReturnStatements2.ts, 81, 1)) if (true) { return (x: Object) => { } ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 87, 16)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 86, 16)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } else { return (x: number) => { } ->x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 89, 16)) +>x : Symbol(x, Decl(functionWithMultipleReturnStatements2.ts, 88, 16)) } } diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.types b/tests/baselines/reference/functionWithMultipleReturnStatements2.types index 4615299bbf19d..6608b0d00a926 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.types +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts === - // return type of a function with multiple returns is the BCT of each return statement // no errors expected here diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.js b/tests/baselines/reference/functionWithNoBestCommonType1.js index 4d197c24334ba..f7114fb40d891 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType1.js +++ b/tests/baselines/reference/functionWithNoBestCommonType1.js @@ -1,5 +1,4 @@ //// [functionWithNoBestCommonType1.ts] - function foo() { return true; return bar(); diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.symbols b/tests/baselines/reference/functionWithNoBestCommonType1.symbols index 826b23f1b48a9..8185ba0239ca4 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType1.symbols +++ b/tests/baselines/reference/functionWithNoBestCommonType1.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/functionWithNoBestCommonType1.ts === - function foo() { >foo : Symbol(foo, Decl(functionWithNoBestCommonType1.ts, 0, 0)) return true; return bar(); ->bar : Symbol(bar, Decl(functionWithNoBestCommonType1.ts, 4, 1)) +>bar : Symbol(bar, Decl(functionWithNoBestCommonType1.ts, 3, 1)) } function bar(): void { ->bar : Symbol(bar, Decl(functionWithNoBestCommonType1.ts, 4, 1)) +>bar : Symbol(bar, Decl(functionWithNoBestCommonType1.ts, 3, 1)) } diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.types b/tests/baselines/reference/functionWithNoBestCommonType1.types index f93ffad337992..d1f8708343882 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType1.types +++ b/tests/baselines/reference/functionWithNoBestCommonType1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/functionWithNoBestCommonType1.ts === - function foo() { >foo : () => true | void diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.js b/tests/baselines/reference/functionWithNoBestCommonType2.js index 06a133b2db8ec..8e903518ec0fb 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType2.js +++ b/tests/baselines/reference/functionWithNoBestCommonType2.js @@ -1,5 +1,4 @@ //// [functionWithNoBestCommonType2.ts] - var v = function () { return true; return bar(); diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.symbols b/tests/baselines/reference/functionWithNoBestCommonType2.symbols index f32f86e67a9e7..eb69c17786611 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType2.symbols +++ b/tests/baselines/reference/functionWithNoBestCommonType2.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/functionWithNoBestCommonType2.ts === - var v = function () { ->v : Symbol(v, Decl(functionWithNoBestCommonType2.ts, 1, 3)) +>v : Symbol(v, Decl(functionWithNoBestCommonType2.ts, 0, 3)) return true; return bar(); ->bar : Symbol(bar, Decl(functionWithNoBestCommonType2.ts, 4, 2)) +>bar : Symbol(bar, Decl(functionWithNoBestCommonType2.ts, 3, 2)) }; function bar(): void { ->bar : Symbol(bar, Decl(functionWithNoBestCommonType2.ts, 4, 2)) +>bar : Symbol(bar, Decl(functionWithNoBestCommonType2.ts, 3, 2)) } diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.types b/tests/baselines/reference/functionWithNoBestCommonType2.types index 76fdbda535f6a..196419f084fdb 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType2.types +++ b/tests/baselines/reference/functionWithNoBestCommonType2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/functionWithNoBestCommonType2.ts === - var v = function () { >v : () => true | void >function () { return true; return bar();} : () => true | void diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt index e0c552141b2f4..e494e6593a005 100644 --- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt +++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt @@ -1,13 +1,11 @@ -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(3,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(101,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(106,16): error TS2378: A 'get' accessor must return a value. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(128,15): error TS2532: Object is possibly 'undefined'. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(129,5): error TS1003: Identifier expected. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(1,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(99,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(104,16): error TS2378: A 'get' accessor must return a value. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(126,15): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(127,5): error TS1003: Identifier expected. ==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (5 errors) ==== - - function f1(): string { ~~~~~~ !!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js index 17468722e207d..3c10c77bef4da 100644 --- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js +++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js @@ -1,6 +1,4 @@ //// [functionsMissingReturnStatementsAndExpressions.ts] - - function f1(): string { // errors because there are no return statements } diff --git a/tests/baselines/reference/generatedContextualTyping.js b/tests/baselines/reference/generatedContextualTyping.js index f8dc28634703f..8b0889f28ae54 100644 --- a/tests/baselines/reference/generatedContextualTyping.js +++ b/tests/baselines/reference/generatedContextualTyping.js @@ -1,5 +1,4 @@ //// [generatedContextualTyping.ts] - class Base { private p; } class Derived1 extends Base { private m; } class Derived2 extends Base { private n; } diff --git a/tests/baselines/reference/generatedContextualTyping.symbols b/tests/baselines/reference/generatedContextualTyping.symbols index a31e38e86482c..780170f24edb9 100644 --- a/tests/baselines/reference/generatedContextualTyping.symbols +++ b/tests/baselines/reference/generatedContextualTyping.symbols @@ -1,2832 +1,2831 @@ === tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts === - class Base { private p; } >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->p : Symbol(Base.p, Decl(generatedContextualTyping.ts, 1, 12)) +>p : Symbol(Base.p, Decl(generatedContextualTyping.ts, 0, 12)) class Derived1 extends Base { private m; } ->Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25)) +>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 0, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->m : Symbol(Derived1.m, Decl(generatedContextualTyping.ts, 2, 29)) +>m : Symbol(Derived1.m, Decl(generatedContextualTyping.ts, 1, 29)) class Derived2 extends Base { private n; } ->Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42)) +>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 1, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(Derived2.n, Decl(generatedContextualTyping.ts, 3, 29)) +>n : Symbol(Derived2.n, Decl(generatedContextualTyping.ts, 2, 29)) interface Genric { func(n: T[]); } ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) ->T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17)) ->func : Symbol(Genric.func, Decl(generatedContextualTyping.ts, 4, 21)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 4, 27)) ->T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>T : Symbol(T, Decl(generatedContextualTyping.ts, 3, 17)) +>func : Symbol(Genric.func, Decl(generatedContextualTyping.ts, 3, 21)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 3, 27)) +>T : Symbol(T, Decl(generatedContextualTyping.ts, 3, 17)) var b = new Base(), d1 = new Derived1(), d2 = new Derived2(); ->b : Symbol(b, Decl(generatedContextualTyping.ts, 5, 3)) +>b : Symbol(b, Decl(generatedContextualTyping.ts, 4, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 0, 25)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 1, 42)) var x1: () => Base[] = () => [d1, d2]; ->x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 6, 3)) +>x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 5, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x2: () => Base[] = function() { return [d1, d2] }; ->x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 7, 3)) +>x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 6, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x3: () => Base[] = function named() { return [d1, d2] }; ->x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 8, 3)) +>x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 7, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 8, 22)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 7, 22)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x4: { (): Base[]; } = () => [d1, d2]; ->x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 9, 3)) +>x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 8, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x5: { (): Base[]; } = function() { return [d1, d2] }; ->x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 10, 3)) +>x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 9, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x6: { (): Base[]; } = function named() { return [d1, d2] }; ->x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 11, 3)) +>x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 10, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 11, 25)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 10, 25)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x7: Base[] = [d1, d2]; ->x7 : Symbol(x7, Decl(generatedContextualTyping.ts, 12, 3)) +>x7 : Symbol(x7, Decl(generatedContextualTyping.ts, 11, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x8: Array = [d1, d2]; ->x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 13, 3)) +>x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 12, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x9: { [n: number]: Base; } = [d1, d2]; ->x9 : Symbol(x9, Decl(generatedContextualTyping.ts, 14, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 11)) +>x9 : Symbol(x9, Decl(generatedContextualTyping.ts, 13, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 13, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x10: {n: Base[]; } = { n: [d1, d2] }; ->x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 15, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 10)) +>x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 14, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 10)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 27)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 27)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x11: (s: Base[]) => any = n => { var n: Base[]; return null; }; ->x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 16, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 16, 10)) +>x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 15, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 15, 10)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x12: Genric = { func: n => { return [d1, d2]; } }; ->x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 17, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 16, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 17, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 17, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 16, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x13 { member: () => Base[] = () => [d1, d2] } ->x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 17, 60)) ->member : Symbol(x13.member, Decl(generatedContextualTyping.ts, 18, 11)) +>x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 16, 60)) +>member : Symbol(x13.member, Decl(generatedContextualTyping.ts, 17, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x14 { member: () => Base[] = function() { return [d1, d2] } } ->x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 18, 51)) ->member : Symbol(x14.member, Decl(generatedContextualTyping.ts, 19, 11)) +>x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 17, 51)) +>member : Symbol(x14.member, Decl(generatedContextualTyping.ts, 18, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x15 { member: () => Base[] = function named() { return [d1, d2] } } ->x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 19, 67)) ->member : Symbol(x15.member, Decl(generatedContextualTyping.ts, 20, 11)) +>x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 18, 67)) +>member : Symbol(x15.member, Decl(generatedContextualTyping.ts, 19, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 20, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 19, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x16 { member: { (): Base[]; } = () => [d1, d2] } ->x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 20, 73)) ->member : Symbol(x16.member, Decl(generatedContextualTyping.ts, 21, 11)) +>x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 19, 73)) +>member : Symbol(x16.member, Decl(generatedContextualTyping.ts, 20, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x17 { member: { (): Base[]; } = function() { return [d1, d2] } } ->x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 21, 54)) ->member : Symbol(x17.member, Decl(generatedContextualTyping.ts, 22, 11)) +>x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 20, 54)) +>member : Symbol(x17.member, Decl(generatedContextualTyping.ts, 21, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } } ->x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 22, 70)) ->member : Symbol(x18.member, Decl(generatedContextualTyping.ts, 23, 11)) +>x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 21, 70)) +>member : Symbol(x18.member, Decl(generatedContextualTyping.ts, 22, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 23, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 22, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x19 { member: Base[] = [d1, d2] } ->x19 : Symbol(x19, Decl(generatedContextualTyping.ts, 23, 76)) ->member : Symbol(x19.member, Decl(generatedContextualTyping.ts, 24, 11)) +>x19 : Symbol(x19, Decl(generatedContextualTyping.ts, 22, 76)) +>member : Symbol(x19.member, Decl(generatedContextualTyping.ts, 23, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x20 { member: Array = [d1, d2] } ->x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 24, 39)) ->member : Symbol(x20.member, Decl(generatedContextualTyping.ts, 25, 11)) +>x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 23, 39)) +>member : Symbol(x20.member, Decl(generatedContextualTyping.ts, 24, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x21 { member: { [n: number]: Base; } = [d1, d2] } ->x21 : Symbol(x21, Decl(generatedContextualTyping.ts, 25, 44)) ->member : Symbol(x21.member, Decl(generatedContextualTyping.ts, 26, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 23)) +>x21 : Symbol(x21, Decl(generatedContextualTyping.ts, 24, 44)) +>member : Symbol(x21.member, Decl(generatedContextualTyping.ts, 25, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 25, 23)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x22 { member: {n: Base[]; } = { n: [d1, d2] } } ->x22 : Symbol(x22, Decl(generatedContextualTyping.ts, 26, 55)) ->member : Symbol(x22.member, Decl(generatedContextualTyping.ts, 27, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 21)) +>x22 : Symbol(x22, Decl(generatedContextualTyping.ts, 25, 55)) +>member : Symbol(x22.member, Decl(generatedContextualTyping.ts, 26, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x23 : Symbol(x23, Decl(generatedContextualTyping.ts, 27, 54)) ->member : Symbol(x23.member, Decl(generatedContextualTyping.ts, 28, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 28, 21)) +>x23 : Symbol(x23, Decl(generatedContextualTyping.ts, 26, 54)) +>member : Symbol(x23.member, Decl(generatedContextualTyping.ts, 27, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 27, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x24 { member: Genric = { func: n => { return [d1, d2]; } } } ->x24 : Symbol(x24, Decl(generatedContextualTyping.ts, 28, 79)) ->member : Symbol(x24.member, Decl(generatedContextualTyping.ts, 29, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x24 : Symbol(x24, Decl(generatedContextualTyping.ts, 27, 79)) +>member : Symbol(x24.member, Decl(generatedContextualTyping.ts, 28, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 29, 36)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 29, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 28, 36)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x25 { private member: () => Base[] = () => [d1, d2] } ->x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 29, 72)) ->member : Symbol(x25.member, Decl(generatedContextualTyping.ts, 30, 11)) +>x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 28, 72)) +>member : Symbol(x25.member, Decl(generatedContextualTyping.ts, 29, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x26 { private member: () => Base[] = function() { return [d1, d2] } } ->x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 30, 59)) ->member : Symbol(x26.member, Decl(generatedContextualTyping.ts, 31, 11)) +>x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 29, 59)) +>member : Symbol(x26.member, Decl(generatedContextualTyping.ts, 30, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x27 { private member: () => Base[] = function named() { return [d1, d2] } } ->x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 31, 75)) ->member : Symbol(x27.member, Decl(generatedContextualTyping.ts, 32, 11)) +>x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 30, 75)) +>member : Symbol(x27.member, Decl(generatedContextualTyping.ts, 31, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 32, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 31, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x28 { private member: { (): Base[]; } = () => [d1, d2] } ->x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 32, 81)) ->member : Symbol(x28.member, Decl(generatedContextualTyping.ts, 33, 11)) +>x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 31, 81)) +>member : Symbol(x28.member, Decl(generatedContextualTyping.ts, 32, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } } ->x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 33, 62)) ->member : Symbol(x29.member, Decl(generatedContextualTyping.ts, 34, 11)) +>x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 32, 62)) +>member : Symbol(x29.member, Decl(generatedContextualTyping.ts, 33, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x30 { private member: { (): Base[]; } = function named() { return [d1, d2] } } ->x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 34, 78)) ->member : Symbol(x30.member, Decl(generatedContextualTyping.ts, 35, 11)) +>x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 33, 78)) +>member : Symbol(x30.member, Decl(generatedContextualTyping.ts, 34, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 35, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 34, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x31 { private member: Base[] = [d1, d2] } ->x31 : Symbol(x31, Decl(generatedContextualTyping.ts, 35, 84)) ->member : Symbol(x31.member, Decl(generatedContextualTyping.ts, 36, 11)) +>x31 : Symbol(x31, Decl(generatedContextualTyping.ts, 34, 84)) +>member : Symbol(x31.member, Decl(generatedContextualTyping.ts, 35, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x32 { private member: Array = [d1, d2] } ->x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 36, 47)) ->member : Symbol(x32.member, Decl(generatedContextualTyping.ts, 37, 11)) +>x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 35, 47)) +>member : Symbol(x32.member, Decl(generatedContextualTyping.ts, 36, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x33 { private member: { [n: number]: Base; } = [d1, d2] } ->x33 : Symbol(x33, Decl(generatedContextualTyping.ts, 37, 52)) ->member : Symbol(x33.member, Decl(generatedContextualTyping.ts, 38, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 31)) +>x33 : Symbol(x33, Decl(generatedContextualTyping.ts, 36, 52)) +>member : Symbol(x33.member, Decl(generatedContextualTyping.ts, 37, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 37, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x34 { private member: {n: Base[]; } = { n: [d1, d2] } } ->x34 : Symbol(x34, Decl(generatedContextualTyping.ts, 38, 63)) ->member : Symbol(x34.member, Decl(generatedContextualTyping.ts, 39, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 29)) +>x34 : Symbol(x34, Decl(generatedContextualTyping.ts, 37, 63)) +>member : Symbol(x34.member, Decl(generatedContextualTyping.ts, 38, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x35 : Symbol(x35, Decl(generatedContextualTyping.ts, 39, 62)) ->member : Symbol(x35.member, Decl(generatedContextualTyping.ts, 40, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 40, 29)) +>x35 : Symbol(x35, Decl(generatedContextualTyping.ts, 38, 62)) +>member : Symbol(x35.member, Decl(generatedContextualTyping.ts, 39, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 39, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x36 { private member: Genric = { func: n => { return [d1, d2]; } } } ->x36 : Symbol(x36, Decl(generatedContextualTyping.ts, 40, 87)) ->member : Symbol(x36.member, Decl(generatedContextualTyping.ts, 41, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x36 : Symbol(x36, Decl(generatedContextualTyping.ts, 39, 87)) +>member : Symbol(x36.member, Decl(generatedContextualTyping.ts, 40, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 41, 44)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 41, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 40, 44)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x37 { public member: () => Base[] = () => [d1, d2] } ->x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 41, 80)) ->member : Symbol(x37.member, Decl(generatedContextualTyping.ts, 42, 11)) +>x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 40, 80)) +>member : Symbol(x37.member, Decl(generatedContextualTyping.ts, 41, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x38 { public member: () => Base[] = function() { return [d1, d2] } } ->x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 42, 58)) ->member : Symbol(x38.member, Decl(generatedContextualTyping.ts, 43, 11)) +>x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 41, 58)) +>member : Symbol(x38.member, Decl(generatedContextualTyping.ts, 42, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x39 { public member: () => Base[] = function named() { return [d1, d2] } } ->x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 43, 74)) ->member : Symbol(x39.member, Decl(generatedContextualTyping.ts, 44, 11)) +>x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 42, 74)) +>member : Symbol(x39.member, Decl(generatedContextualTyping.ts, 43, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 44, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 43, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x40 { public member: { (): Base[]; } = () => [d1, d2] } ->x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 44, 80)) ->member : Symbol(x40.member, Decl(generatedContextualTyping.ts, 45, 11)) +>x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 43, 80)) +>member : Symbol(x40.member, Decl(generatedContextualTyping.ts, 44, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } } ->x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 45, 61)) ->member : Symbol(x41.member, Decl(generatedContextualTyping.ts, 46, 11)) +>x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 44, 61)) +>member : Symbol(x41.member, Decl(generatedContextualTyping.ts, 45, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x42 { public member: { (): Base[]; } = function named() { return [d1, d2] } } ->x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 46, 77)) ->member : Symbol(x42.member, Decl(generatedContextualTyping.ts, 47, 11)) +>x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 45, 77)) +>member : Symbol(x42.member, Decl(generatedContextualTyping.ts, 46, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 47, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 46, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x43 { public member: Base[] = [d1, d2] } ->x43 : Symbol(x43, Decl(generatedContextualTyping.ts, 47, 83)) ->member : Symbol(x43.member, Decl(generatedContextualTyping.ts, 48, 11)) +>x43 : Symbol(x43, Decl(generatedContextualTyping.ts, 46, 83)) +>member : Symbol(x43.member, Decl(generatedContextualTyping.ts, 47, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x44 { public member: Array = [d1, d2] } ->x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 48, 46)) ->member : Symbol(x44.member, Decl(generatedContextualTyping.ts, 49, 11)) +>x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 47, 46)) +>member : Symbol(x44.member, Decl(generatedContextualTyping.ts, 48, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x45 { public member: { [n: number]: Base; } = [d1, d2] } ->x45 : Symbol(x45, Decl(generatedContextualTyping.ts, 49, 51)) ->member : Symbol(x45.member, Decl(generatedContextualTyping.ts, 50, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 30)) +>x45 : Symbol(x45, Decl(generatedContextualTyping.ts, 48, 51)) +>member : Symbol(x45.member, Decl(generatedContextualTyping.ts, 49, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 49, 30)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x46 { public member: {n: Base[]; } = { n: [d1, d2] } } ->x46 : Symbol(x46, Decl(generatedContextualTyping.ts, 50, 62)) ->member : Symbol(x46.member, Decl(generatedContextualTyping.ts, 51, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 28)) +>x46 : Symbol(x46, Decl(generatedContextualTyping.ts, 49, 62)) +>member : Symbol(x46.member, Decl(generatedContextualTyping.ts, 50, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x47 : Symbol(x47, Decl(generatedContextualTyping.ts, 51, 61)) ->member : Symbol(x47.member, Decl(generatedContextualTyping.ts, 52, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 52, 28)) +>x47 : Symbol(x47, Decl(generatedContextualTyping.ts, 50, 61)) +>member : Symbol(x47.member, Decl(generatedContextualTyping.ts, 51, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 51, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x48 { public member: Genric = { func: n => { return [d1, d2]; } } } ->x48 : Symbol(x48, Decl(generatedContextualTyping.ts, 52, 86)) ->member : Symbol(x48.member, Decl(generatedContextualTyping.ts, 53, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x48 : Symbol(x48, Decl(generatedContextualTyping.ts, 51, 86)) +>member : Symbol(x48.member, Decl(generatedContextualTyping.ts, 52, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 53, 43)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 53, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 52, 43)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x49 { static member: () => Base[] = () => [d1, d2] } ->x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 53, 79)) ->member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 54, 11)) +>x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 52, 79)) +>member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 53, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x50 { static member: () => Base[] = function() { return [d1, d2] } } ->x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 54, 58)) ->member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 55, 11)) +>x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 53, 58)) +>member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 54, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x51 { static member: () => Base[] = function named() { return [d1, d2] } } ->x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 55, 74)) ->member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 56, 11)) +>x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 54, 74)) +>member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 55, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 56, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 55, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x52 { static member: { (): Base[]; } = () => [d1, d2] } ->x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 56, 80)) ->member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 57, 11)) +>x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 55, 80)) +>member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 56, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } } ->x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 57, 61)) ->member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 58, 11)) +>x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 56, 61)) +>member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 57, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x54 { static member: { (): Base[]; } = function named() { return [d1, d2] } } ->x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 58, 77)) ->member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 59, 11)) +>x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 57, 77)) +>member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 58, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 59, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 58, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x55 { static member: Base[] = [d1, d2] } ->x55 : Symbol(x55, Decl(generatedContextualTyping.ts, 59, 83)) ->member : Symbol(x55.member, Decl(generatedContextualTyping.ts, 60, 11)) +>x55 : Symbol(x55, Decl(generatedContextualTyping.ts, 58, 83)) +>member : Symbol(x55.member, Decl(generatedContextualTyping.ts, 59, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x56 { static member: Array = [d1, d2] } ->x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 60, 46)) ->member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 61, 11)) +>x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 59, 46)) +>member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 60, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x57 { static member: { [n: number]: Base; } = [d1, d2] } ->x57 : Symbol(x57, Decl(generatedContextualTyping.ts, 61, 51)) ->member : Symbol(x57.member, Decl(generatedContextualTyping.ts, 62, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 30)) +>x57 : Symbol(x57, Decl(generatedContextualTyping.ts, 60, 51)) +>member : Symbol(x57.member, Decl(generatedContextualTyping.ts, 61, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 61, 30)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x58 { static member: {n: Base[]; } = { n: [d1, d2] } } ->x58 : Symbol(x58, Decl(generatedContextualTyping.ts, 62, 62)) ->member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 63, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 28)) +>x58 : Symbol(x58, Decl(generatedContextualTyping.ts, 61, 62)) +>member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 62, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x59 : Symbol(x59, Decl(generatedContextualTyping.ts, 63, 61)) ->member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 64, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 64, 28)) +>x59 : Symbol(x59, Decl(generatedContextualTyping.ts, 62, 61)) +>member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 63, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 63, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x60 { static member: Genric = { func: n => { return [d1, d2]; } } } ->x60 : Symbol(x60, Decl(generatedContextualTyping.ts, 64, 86)) ->member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 65, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x60 : Symbol(x60, Decl(generatedContextualTyping.ts, 63, 86)) +>member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 64, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 65, 43)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 65, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 64, 43)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x61 { private static member: () => Base[] = () => [d1, d2] } ->x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 65, 79)) ->member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 66, 11)) +>x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 64, 79)) +>member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 65, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x62 { private static member: () => Base[] = function() { return [d1, d2] } } ->x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 66, 66)) ->member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 67, 11)) +>x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 65, 66)) +>member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 66, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x63 { private static member: () => Base[] = function named() { return [d1, d2] } } ->x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 67, 82)) ->member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 68, 11)) +>x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 66, 82)) +>member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 67, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 68, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 67, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x64 { private static member: { (): Base[]; } = () => [d1, d2] } ->x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 68, 88)) ->member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 69, 11)) +>x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 67, 88)) +>member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 68, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x65 { private static member: { (): Base[]; } = function() { return [d1, d2] } } ->x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 69, 69)) ->member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 70, 11)) +>x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 68, 69)) +>member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 69, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x66 { private static member: { (): Base[]; } = function named() { return [d1, d2] } } ->x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 70, 85)) ->member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 71, 11)) +>x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 69, 85)) +>member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 70, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 71, 52)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 70, 52)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x67 { private static member: Base[] = [d1, d2] } ->x67 : Symbol(x67, Decl(generatedContextualTyping.ts, 71, 91)) ->member : Symbol(x67.member, Decl(generatedContextualTyping.ts, 72, 11)) +>x67 : Symbol(x67, Decl(generatedContextualTyping.ts, 70, 91)) +>member : Symbol(x67.member, Decl(generatedContextualTyping.ts, 71, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x68 { private static member: Array = [d1, d2] } ->x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 72, 54)) ->member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 73, 11)) +>x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 71, 54)) +>member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 72, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x69 { private static member: { [n: number]: Base; } = [d1, d2] } ->x69 : Symbol(x69, Decl(generatedContextualTyping.ts, 73, 59)) ->member : Symbol(x69.member, Decl(generatedContextualTyping.ts, 74, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 38)) +>x69 : Symbol(x69, Decl(generatedContextualTyping.ts, 72, 59)) +>member : Symbol(x69.member, Decl(generatedContextualTyping.ts, 73, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 73, 38)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x70 { private static member: {n: Base[]; } = { n: [d1, d2] } } ->x70 : Symbol(x70, Decl(generatedContextualTyping.ts, 74, 70)) ->member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 75, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 36)) +>x70 : Symbol(x70, Decl(generatedContextualTyping.ts, 73, 70)) +>member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 74, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 36)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x71 : Symbol(x71, Decl(generatedContextualTyping.ts, 75, 69)) ->member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 76, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 76, 36)) +>x71 : Symbol(x71, Decl(generatedContextualTyping.ts, 74, 69)) +>member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 75, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 75, 36)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x72 { private static member: Genric = { func: n => { return [d1, d2]; } } } ->x72 : Symbol(x72, Decl(generatedContextualTyping.ts, 76, 94)) ->member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 77, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x72 : Symbol(x72, Decl(generatedContextualTyping.ts, 75, 94)) +>member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 76, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 77, 51)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 77, 57)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 76, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 57)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x73 { public static member: () => Base[] = () => [d1, d2] } ->x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 77, 87)) ->member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 78, 11)) +>x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 76, 87)) +>member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 77, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x74 { public static member: () => Base[] = function() { return [d1, d2] } } ->x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 78, 65)) ->member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 79, 11)) +>x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 77, 65)) +>member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 78, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x75 { public static member: () => Base[] = function named() { return [d1, d2] } } ->x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 79, 81)) ->member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 80, 11)) +>x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 78, 81)) +>member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 79, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 80, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 79, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x76 { public static member: { (): Base[]; } = () => [d1, d2] } ->x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 80, 87)) ->member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 81, 11)) +>x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 79, 87)) +>member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 80, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x77 { public static member: { (): Base[]; } = function() { return [d1, d2] } } ->x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 81, 68)) ->member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 82, 11)) +>x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 80, 68)) +>member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 81, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x78 { public static member: { (): Base[]; } = function named() { return [d1, d2] } } ->x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 82, 84)) ->member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 83, 11)) +>x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 81, 84)) +>member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 82, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 83, 51)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 82, 51)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x79 { public static member: Base[] = [d1, d2] } ->x79 : Symbol(x79, Decl(generatedContextualTyping.ts, 83, 90)) ->member : Symbol(x79.member, Decl(generatedContextualTyping.ts, 84, 11)) +>x79 : Symbol(x79, Decl(generatedContextualTyping.ts, 82, 90)) +>member : Symbol(x79.member, Decl(generatedContextualTyping.ts, 83, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x80 { public static member: Array = [d1, d2] } ->x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 84, 53)) ->member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 85, 11)) +>x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 83, 53)) +>member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 84, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x81 { public static member: { [n: number]: Base; } = [d1, d2] } ->x81 : Symbol(x81, Decl(generatedContextualTyping.ts, 85, 58)) ->member : Symbol(x81.member, Decl(generatedContextualTyping.ts, 86, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 37)) +>x81 : Symbol(x81, Decl(generatedContextualTyping.ts, 84, 58)) +>member : Symbol(x81.member, Decl(generatedContextualTyping.ts, 85, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 85, 37)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x82 { public static member: {n: Base[]; } = { n: [d1, d2] } } ->x82 : Symbol(x82, Decl(generatedContextualTyping.ts, 86, 69)) ->member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 87, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 35)) +>x82 : Symbol(x82, Decl(generatedContextualTyping.ts, 85, 69)) +>member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 86, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 35)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 52)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 52)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x83 : Symbol(x83, Decl(generatedContextualTyping.ts, 87, 68)) ->member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 88, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 88, 35)) +>x83 : Symbol(x83, Decl(generatedContextualTyping.ts, 86, 68)) +>member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 87, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 87, 35)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x84 { public static member: Genric = { func: n => { return [d1, d2]; } } } ->x84 : Symbol(x84, Decl(generatedContextualTyping.ts, 88, 93)) ->member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 89, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x84 : Symbol(x84, Decl(generatedContextualTyping.ts, 87, 93)) +>member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 88, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 89, 50)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 89, 56)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 88, 50)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 56)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } } ->x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 89, 86)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24)) +>x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 88, 86)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 89, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { } } ->x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 90, 66)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24)) +>x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 89, 66)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2] }) { } } ->x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 91, 82)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24)) +>x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 90, 82)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 92, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 91, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } } ->x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 92, 88)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24)) +>x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 91, 88)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] }) { } } ->x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 93, 69)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24)) +>x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 92, 69)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } } ->x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 94, 85)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 95, 24)) +>x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 93, 85)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 95, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 94, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x91 { constructor(parm: Base[] = [d1, d2]) { } } ->x91 : Symbol(x91, Decl(generatedContextualTyping.ts, 95, 91)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24)) +>x91 : Symbol(x91, Decl(generatedContextualTyping.ts, 94, 91)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 95, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x92 { constructor(parm: Array = [d1, d2]) { } } ->x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 96, 54)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 97, 24)) +>x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 95, 54)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x93 { constructor(parm: { [n: number]: Base; } = [d1, d2]) { } } ->x93 : Symbol(x93, Decl(generatedContextualTyping.ts, 97, 59)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 33)) +>x93 : Symbol(x93, Decl(generatedContextualTyping.ts, 96, 59)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 97, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 97, 33)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x94 { constructor(parm: {n: Base[]; } = { n: [d1, d2] }) { } } ->x94 : Symbol(x94, Decl(generatedContextualTyping.ts, 98, 70)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 31)) +>x94 : Symbol(x94, Decl(generatedContextualTyping.ts, 97, 70)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } } ->x95 : Symbol(x95, Decl(generatedContextualTyping.ts, 99, 69)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 100, 31)) +>x95 : Symbol(x95, Decl(generatedContextualTyping.ts, 98, 69)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 99, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x96 { constructor(parm: Genric = { func: n => { return [d1, d2]; } }) { } } ->x96 : Symbol(x96, Decl(generatedContextualTyping.ts, 100, 94)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 101, 24)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x96 : Symbol(x96, Decl(generatedContextualTyping.ts, 99, 94)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 101, 46)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 101, 52)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 100, 46)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 52)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } } ->x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 101, 87)) ->parm : Symbol(x97.parm, Decl(generatedContextualTyping.ts, 102, 24)) +>x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 100, 87)) +>parm : Symbol(x97.parm, Decl(generatedContextualTyping.ts, 101, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2] }) { } } ->x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 102, 73)) ->parm : Symbol(x98.parm, Decl(generatedContextualTyping.ts, 103, 24)) +>x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 101, 73)) +>parm : Symbol(x98.parm, Decl(generatedContextualTyping.ts, 102, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x99 { constructor(public parm: () => Base[] = function named() { return [d1, d2] }) { } } ->x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 103, 89)) ->parm : Symbol(x99.parm, Decl(generatedContextualTyping.ts, 104, 24)) +>x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 102, 89)) +>parm : Symbol(x99.parm, Decl(generatedContextualTyping.ts, 103, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 104, 51)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 103, 51)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } } ->x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 104, 95)) ->parm : Symbol(x100.parm, Decl(generatedContextualTyping.ts, 105, 25)) +>x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 103, 95)) +>parm : Symbol(x100.parm, Decl(generatedContextualTyping.ts, 104, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1, d2] }) { } } ->x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 105, 77)) ->parm : Symbol(x101.parm, Decl(generatedContextualTyping.ts, 106, 25)) +>x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 104, 77)) +>parm : Symbol(x101.parm, Decl(generatedContextualTyping.ts, 105, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x102 { constructor(public parm: { (): Base[]; } = function named() { return [d1, d2] }) { } } ->x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 106, 93)) ->parm : Symbol(x102.parm, Decl(generatedContextualTyping.ts, 107, 25)) +>x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 105, 93)) +>parm : Symbol(x102.parm, Decl(generatedContextualTyping.ts, 106, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 107, 55)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 106, 55)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x103 { constructor(public parm: Base[] = [d1, d2]) { } } ->x103 : Symbol(x103, Decl(generatedContextualTyping.ts, 107, 99)) ->parm : Symbol(x103.parm, Decl(generatedContextualTyping.ts, 108, 25)) +>x103 : Symbol(x103, Decl(generatedContextualTyping.ts, 106, 99)) +>parm : Symbol(x103.parm, Decl(generatedContextualTyping.ts, 107, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x104 { constructor(public parm: Array = [d1, d2]) { } } ->x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 108, 62)) ->parm : Symbol(x104.parm, Decl(generatedContextualTyping.ts, 109, 25)) +>x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 107, 62)) +>parm : Symbol(x104.parm, Decl(generatedContextualTyping.ts, 108, 25)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x105 { constructor(public parm: { [n: number]: Base; } = [d1, d2]) { } } ->x105 : Symbol(x105, Decl(generatedContextualTyping.ts, 109, 67)) ->parm : Symbol(x105.parm, Decl(generatedContextualTyping.ts, 110, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 41)) +>x105 : Symbol(x105, Decl(generatedContextualTyping.ts, 108, 67)) +>parm : Symbol(x105.parm, Decl(generatedContextualTyping.ts, 109, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 109, 41)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x106 { constructor(public parm: {n: Base[]; } = { n: [d1, d2] }) { } } ->x106 : Symbol(x106, Decl(generatedContextualTyping.ts, 110, 78)) ->parm : Symbol(x106.parm, Decl(generatedContextualTyping.ts, 111, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 39)) +>x106 : Symbol(x106, Decl(generatedContextualTyping.ts, 109, 78)) +>parm : Symbol(x106.parm, Decl(generatedContextualTyping.ts, 110, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 39)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 56)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 56)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } } ->x107 : Symbol(x107, Decl(generatedContextualTyping.ts, 111, 77)) ->parm : Symbol(x107.parm, Decl(generatedContextualTyping.ts, 112, 25)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 112, 39)) +>x107 : Symbol(x107, Decl(generatedContextualTyping.ts, 110, 77)) +>parm : Symbol(x107.parm, Decl(generatedContextualTyping.ts, 111, 25)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 111, 39)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x108 { constructor(public parm: Genric = { func: n => { return [d1, d2]; } }) { } } ->x108 : Symbol(x108, Decl(generatedContextualTyping.ts, 112, 102)) ->parm : Symbol(x108.parm, Decl(generatedContextualTyping.ts, 113, 25)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x108 : Symbol(x108, Decl(generatedContextualTyping.ts, 111, 102)) +>parm : Symbol(x108.parm, Decl(generatedContextualTyping.ts, 112, 25)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 113, 54)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 113, 60)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 112, 54)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 60)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } } ->x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 113, 95)) ->parm : Symbol(x109.parm, Decl(generatedContextualTyping.ts, 114, 25)) +>x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 112, 95)) +>parm : Symbol(x109.parm, Decl(generatedContextualTyping.ts, 113, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x110 { constructor(private parm: () => Base[] = function() { return [d1, d2] }) { } } ->x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 114, 75)) ->parm : Symbol(x110.parm, Decl(generatedContextualTyping.ts, 115, 25)) +>x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 113, 75)) +>parm : Symbol(x110.parm, Decl(generatedContextualTyping.ts, 114, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x111 { constructor(private parm: () => Base[] = function named() { return [d1, d2] }) { } } ->x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 115, 91)) ->parm : Symbol(x111.parm, Decl(generatedContextualTyping.ts, 116, 25)) +>x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 114, 91)) +>parm : Symbol(x111.parm, Decl(generatedContextualTyping.ts, 115, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 116, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 115, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } } ->x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 116, 97)) ->parm : Symbol(x112.parm, Decl(generatedContextualTyping.ts, 117, 25)) +>x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 115, 97)) +>parm : Symbol(x112.parm, Decl(generatedContextualTyping.ts, 116, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1, d2] }) { } } ->x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 117, 78)) ->parm : Symbol(x113.parm, Decl(generatedContextualTyping.ts, 118, 25)) +>x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 116, 78)) +>parm : Symbol(x113.parm, Decl(generatedContextualTyping.ts, 117, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x114 { constructor(private parm: { (): Base[]; } = function named() { return [d1, d2] }) { } } ->x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 118, 94)) ->parm : Symbol(x114.parm, Decl(generatedContextualTyping.ts, 119, 25)) +>x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 117, 94)) +>parm : Symbol(x114.parm, Decl(generatedContextualTyping.ts, 118, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 119, 56)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 118, 56)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x115 { constructor(private parm: Base[] = [d1, d2]) { } } ->x115 : Symbol(x115, Decl(generatedContextualTyping.ts, 119, 100)) ->parm : Symbol(x115.parm, Decl(generatedContextualTyping.ts, 120, 25)) +>x115 : Symbol(x115, Decl(generatedContextualTyping.ts, 118, 100)) +>parm : Symbol(x115.parm, Decl(generatedContextualTyping.ts, 119, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x116 { constructor(private parm: Array = [d1, d2]) { } } ->x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 120, 63)) ->parm : Symbol(x116.parm, Decl(generatedContextualTyping.ts, 121, 25)) +>x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 119, 63)) +>parm : Symbol(x116.parm, Decl(generatedContextualTyping.ts, 120, 25)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x117 { constructor(private parm: { [n: number]: Base; } = [d1, d2]) { } } ->x117 : Symbol(x117, Decl(generatedContextualTyping.ts, 121, 68)) ->parm : Symbol(x117.parm, Decl(generatedContextualTyping.ts, 122, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 42)) +>x117 : Symbol(x117, Decl(generatedContextualTyping.ts, 120, 68)) +>parm : Symbol(x117.parm, Decl(generatedContextualTyping.ts, 121, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 121, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x118 { constructor(private parm: {n: Base[]; } = { n: [d1, d2] }) { } } ->x118 : Symbol(x118, Decl(generatedContextualTyping.ts, 122, 79)) ->parm : Symbol(x118.parm, Decl(generatedContextualTyping.ts, 123, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 40)) +>x118 : Symbol(x118, Decl(generatedContextualTyping.ts, 121, 79)) +>parm : Symbol(x118.parm, Decl(generatedContextualTyping.ts, 122, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 40)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 57)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 57)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } } ->x119 : Symbol(x119, Decl(generatedContextualTyping.ts, 123, 78)) ->parm : Symbol(x119.parm, Decl(generatedContextualTyping.ts, 124, 25)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 124, 40)) +>x119 : Symbol(x119, Decl(generatedContextualTyping.ts, 122, 78)) +>parm : Symbol(x119.parm, Decl(generatedContextualTyping.ts, 123, 25)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 123, 40)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x120 { constructor(private parm: Genric = { func: n => { return [d1, d2]; } }) { } } ->x120 : Symbol(x120, Decl(generatedContextualTyping.ts, 124, 103)) ->parm : Symbol(x120.parm, Decl(generatedContextualTyping.ts, 125, 25)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x120 : Symbol(x120, Decl(generatedContextualTyping.ts, 123, 103)) +>parm : Symbol(x120.parm, Decl(generatedContextualTyping.ts, 124, 25)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 125, 55)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 125, 61)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 124, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 61)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x121(parm: () => Base[] = () => [d1, d2]) { } ->x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 125, 96)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14)) +>x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 124, 96)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 125, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x122(parm: () => Base[] = function() { return [d1, d2] }) { } ->x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 126, 54)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14)) +>x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 125, 54)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x123(parm: () => Base[] = function named() { return [d1, d2] }) { } ->x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 127, 70)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14)) +>x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 126, 70)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 128, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 127, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x124(parm: { (): Base[]; } = () => [d1, d2]) { } ->x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 128, 76)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14)) +>x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 127, 76)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { } ->x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 129, 57)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14)) +>x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 128, 57)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } ->x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 130, 73)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 131, 14)) +>x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 129, 73)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 131, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 130, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x127(parm: Base[] = [d1, d2]) { } ->x127 : Symbol(x127, Decl(generatedContextualTyping.ts, 131, 79)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14)) +>x127 : Symbol(x127, Decl(generatedContextualTyping.ts, 130, 79)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 131, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x128(parm: Array = [d1, d2]) { } ->x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 132, 42)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 133, 14)) +>x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 131, 42)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x129(parm: { [n: number]: Base; } = [d1, d2]) { } ->x129 : Symbol(x129, Decl(generatedContextualTyping.ts, 133, 47)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 23)) +>x129 : Symbol(x129, Decl(generatedContextualTyping.ts, 132, 47)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 133, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 133, 23)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x130(parm: {n: Base[]; } = { n: [d1, d2] }) { } ->x130 : Symbol(x130, Decl(generatedContextualTyping.ts, 134, 58)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 21)) +>x130 : Symbol(x130, Decl(generatedContextualTyping.ts, 133, 58)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } ->x131 : Symbol(x131, Decl(generatedContextualTyping.ts, 135, 57)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 136, 21)) +>x131 : Symbol(x131, Decl(generatedContextualTyping.ts, 134, 57)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 135, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x132(parm: Genric = { func: n => { return [d1, d2]; } }) { } ->x132 : Symbol(x132, Decl(generatedContextualTyping.ts, 136, 82)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 137, 14)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x132 : Symbol(x132, Decl(generatedContextualTyping.ts, 135, 82)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 137, 36)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 137, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 136, 36)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x133(): () => Base[] { return () => [d1, d2]; } ->x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 137, 75)) +>x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 136, 75)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x134(): () => Base[] { return function() { return [d1, d2] }; } ->x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 138, 56)) +>x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 137, 56)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x135(): () => Base[] { return function named() { return [d1, d2] }; } ->x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 139, 72)) +>x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 138, 72)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 140, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 139, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x136(): { (): Base[]; } { return () => [d1, d2]; } ->x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 140, 78)) +>x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 139, 78)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x137(): { (): Base[]; } { return function() { return [d1, d2] }; } ->x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 141, 59)) +>x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 140, 59)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; } ->x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 142, 75)) +>x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 141, 75)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 143, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 142, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x139(): Base[] { return [d1, d2]; } ->x139 : Symbol(x139, Decl(generatedContextualTyping.ts, 143, 81)) +>x139 : Symbol(x139, Decl(generatedContextualTyping.ts, 142, 81)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x140(): Array { return [d1, d2]; } ->x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 144, 44)) +>x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 143, 44)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x141(): { [n: number]: Base; } { return [d1, d2]; } ->x141 : Symbol(x141, Decl(generatedContextualTyping.ts, 145, 49)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 20)) +>x141 : Symbol(x141, Decl(generatedContextualTyping.ts, 144, 49)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 145, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x142(): {n: Base[]; } { return { n: [d1, d2] }; } ->x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 146, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 18)) +>x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 145, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; } ->x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 147, 59)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 148, 18)) +>x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 146, 59)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 147, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x144(): Genric { return { func: n => { return [d1, d2]; } }; } ->x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 148, 84)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 147, 84)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 149, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 149, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 148, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; } ->x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 149, 77)) +>x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 148, 77)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; } ->x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 150, 79)) +>x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 149, 79)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; } ->x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 151, 111)) +>x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 150, 111)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 83)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 83)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; } ->x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 152, 123)) +>x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 151, 123)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; } ->x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 153, 82)) +>x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 152, 82)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; } ->x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 154, 114)) +>x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 153, 114)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 86)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 86)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x151(): Base[] { return [d1, d2]; return [d1, d2]; } ->x151 : Symbol(x151, Decl(generatedContextualTyping.ts, 155, 126)) +>x151 : Symbol(x151, Decl(generatedContextualTyping.ts, 154, 126)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x152(): Array { return [d1, d2]; return [d1, d2]; } ->x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 156, 61)) +>x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 155, 61)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; } ->x153 : Symbol(x153, Decl(generatedContextualTyping.ts, 157, 66)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 20)) +>x153 : Symbol(x153, Decl(generatedContextualTyping.ts, 156, 66)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 157, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x154(): {n: Base[]; } { return { n: [d1, d2] }; return { n: [d1, d2] }; } ->x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 158, 77)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 18)) +>x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 157, 77)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 66)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 66)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; return n => { var n: Base[]; return null; }; } ->x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 159, 83)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 160, 18)) +>x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 158, 83)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 159, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x156(): Genric { return { func: n => { return [d1, d2]; } }; return { func: n => { return [d1, d2]; } }; } ->x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 160, 129)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 84)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 90)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 159, 129)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 84)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 90)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x157: () => () => Base[] = () => { return () => [d1, d2]; }; ->x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 162, 3)) +>x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 161, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; }; ->x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 163, 3)) +>x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 162, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; }; ->x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 164, 3)) +>x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 163, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 164, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 163, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; }; ->x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 165, 3)) +>x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 164, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; }; ->x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 166, 3)) +>x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 165, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; }; ->x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 167, 3)) +>x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 166, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 167, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 166, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x163: () => Base[] = () => { return [d1, d2]; }; ->x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 168, 3)) +>x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 167, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x164: () => Array = () => { return [d1, d2]; }; ->x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 169, 3)) +>x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 168, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; }; ->x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 170, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 19)) +>x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 169, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 169, 19)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x166: () => {n: Base[]; } = () => { return { n: [d1, d2] }; }; ->x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 171, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 17)) +>x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 170, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return null; }; }; ->x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 172, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 172, 17)) +>x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 171, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 171, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x168: () => Genric = () => { return { func: n => { return [d1, d2]; } }; }; ->x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 173, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 172, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 173, 47)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 173, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 172, 47)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x169: () => () => Base[] = function() { return () => [d1, d2]; }; ->x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 174, 3)) +>x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 173, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; }; ->x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 175, 3)) +>x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 174, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; }; ->x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 176, 3)) +>x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 175, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 176, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 175, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; }; ->x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 177, 3)) +>x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 176, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; }; ->x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 178, 3)) +>x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 177, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; }; ->x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 179, 3)) +>x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 178, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 179, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 178, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x175: () => Base[] = function() { return [d1, d2]; }; ->x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 180, 3)) +>x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 179, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x176: () => Array = function() { return [d1, d2]; }; ->x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 181, 3)) +>x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 180, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; }; ->x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 182, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 19)) +>x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 181, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 181, 19)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x178: () => {n: Base[]; } = function() { return { n: [d1, d2] }; }; ->x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 183, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 17)) +>x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 182, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 54)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 54)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; return null; }; }; ->x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 184, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 184, 17)) +>x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 183, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 183, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x180: () => Genric = function() { return { func: n => { return [d1, d2]; } }; }; ->x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 185, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 184, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 185, 52)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 185, 58)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 184, 52)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 58)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x181 { var t: () => Base[] = () => [d1, d2]; } ->x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 185, 90)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17)) +>x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 184, 90)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 185, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x182 { var t: () => Base[] = function() { return [d1, d2] }; } ->x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 186, 53)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17)) +>x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 185, 53)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x183 { var t: () => Base[] = function named() { return [d1, d2] }; } ->x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 187, 69)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17)) +>x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 186, 69)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 188, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 187, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x184 { var t: { (): Base[]; } = () => [d1, d2]; } ->x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 188, 75)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17)) +>x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 187, 75)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; } ->x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 189, 56)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17)) +>x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 188, 56)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; } ->x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 190, 72)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 191, 17)) +>x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 189, 72)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 191, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 190, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x187 { var t: Base[] = [d1, d2]; } ->x187 : Symbol(x187, Decl(generatedContextualTyping.ts, 191, 78)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17)) +>x187 : Symbol(x187, Decl(generatedContextualTyping.ts, 190, 78)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 191, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x188 { var t: Array = [d1, d2]; } ->x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 192, 41)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 193, 17)) +>x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 191, 41)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x189 { var t: { [n: number]: Base; } = [d1, d2]; } ->x189 : Symbol(x189, Decl(generatedContextualTyping.ts, 193, 46)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 24)) +>x189 : Symbol(x189, Decl(generatedContextualTyping.ts, 192, 46)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 193, 17)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 193, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x190 { var t: {n: Base[]; } = { n: [d1, d2] }; } ->x190 : Symbol(x190, Decl(generatedContextualTyping.ts, 194, 57)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 22)) +>x190 : Symbol(x190, Decl(generatedContextualTyping.ts, 193, 57)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 22)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; } ->x191 : Symbol(x191, Decl(generatedContextualTyping.ts, 195, 56)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 196, 22)) +>x191 : Symbol(x191, Decl(generatedContextualTyping.ts, 194, 56)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 195, 22)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) module x192 { var t: Genric = { func: n => { return [d1, d2]; } }; } ->x192 : Symbol(x192, Decl(generatedContextualTyping.ts, 196, 81)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 17)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x192 : Symbol(x192, Decl(generatedContextualTyping.ts, 195, 81)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 197, 37)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 197, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 196, 37)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x193 { export var t: () => Base[] = () => [d1, d2]; } ->x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 197, 74)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24)) +>x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 196, 74)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x194 { export var t: () => Base[] = function() { return [d1, d2] }; } ->x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 198, 60)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24)) +>x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 197, 60)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x195 { export var t: () => Base[] = function named() { return [d1, d2] }; } ->x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 199, 76)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24)) +>x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 198, 76)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 200, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 199, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x196 { export var t: { (): Base[]; } = () => [d1, d2]; } ->x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 200, 82)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24)) +>x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 199, 82)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; } ->x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 201, 63)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24)) +>x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 200, 63)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2] }; } ->x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 202, 79)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 203, 24)) +>x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 201, 79)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 203, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 202, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x199 { export var t: Base[] = [d1, d2]; } ->x199 : Symbol(x199, Decl(generatedContextualTyping.ts, 203, 85)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24)) +>x199 : Symbol(x199, Decl(generatedContextualTyping.ts, 202, 85)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 203, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x200 { export var t: Array = [d1, d2]; } ->x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 204, 48)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 205, 24)) +>x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 203, 48)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x201 { export var t: { [n: number]: Base; } = [d1, d2]; } ->x201 : Symbol(x201, Decl(generatedContextualTyping.ts, 205, 53)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 31)) +>x201 : Symbol(x201, Decl(generatedContextualTyping.ts, 204, 53)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 205, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 205, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x202 { export var t: {n: Base[]; } = { n: [d1, d2] }; } ->x202 : Symbol(x202, Decl(generatedContextualTyping.ts, 206, 64)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 29)) +>x202 : Symbol(x202, Decl(generatedContextualTyping.ts, 205, 64)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; } ->x203 : Symbol(x203, Decl(generatedContextualTyping.ts, 207, 63)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 208, 29)) +>x203 : Symbol(x203, Decl(generatedContextualTyping.ts, 206, 63)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 207, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) module x204 { export var t: Genric = { func: n => { return [d1, d2]; } }; } ->x204 : Symbol(x204, Decl(generatedContextualTyping.ts, 208, 88)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 209, 24)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x204 : Symbol(x204, Decl(generatedContextualTyping.ts, 207, 88)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 209, 44)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 209, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 208, 44)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x206 = <() => Base[]>function() { return [d1, d2] }; ->x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 210, 3)) +>x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 209, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x207 = <() => Base[]>function named() { return [d1, d2] }; ->x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 211, 3)) +>x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 210, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 211, 25)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 210, 25)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x209 = <{ (): Base[]; }>function() { return [d1, d2] }; ->x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 212, 3)) +>x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 211, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x210 = <{ (): Base[]; }>function named() { return [d1, d2] }; ->x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 213, 3)) +>x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 212, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 213, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 212, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x211 = [d1, d2]; ->x211 : Symbol(x211, Decl(generatedContextualTyping.ts, 214, 3)) +>x211 : Symbol(x211, Decl(generatedContextualTyping.ts, 213, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x212 = >[d1, d2]; ->x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 215, 3)) +>x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 214, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x213 = <{ [n: number]: Base; }>[d1, d2]; ->x213 : Symbol(x213, Decl(generatedContextualTyping.ts, 216, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 15)) +>x213 : Symbol(x213, Decl(generatedContextualTyping.ts, 215, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 215, 15)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x214 = <{n: Base[]; } >{ n: [d1, d2] }; ->x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 217, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 13)) +>x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 216, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x216 = >{ func: n => { return [d1, d2]; } }; ->x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 218, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 217, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 218, 26)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 218, 32)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 217, 26)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 32)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] }; ->x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 219, 3)) +>x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 218, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] }; ->x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 220, 3)) +>x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 219, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 220, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 219, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] }; ->x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 221, 3)) +>x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 220, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] }; ->x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 222, 3)) +>x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 221, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 222, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 221, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x221 = (undefined) || [d1, d2]; ->x221 : Symbol(x221, Decl(generatedContextualTyping.ts, 223, 3)) +>x221 : Symbol(x221, Decl(generatedContextualTyping.ts, 222, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x222 = (>undefined) || [d1, d2]; ->x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 224, 3)) +>x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 223, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2]; ->x223 : Symbol(x223, Decl(generatedContextualTyping.ts, 225, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 16)) +>x223 : Symbol(x223, Decl(generatedContextualTyping.ts, 224, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 224, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] }; ->x224 : Symbol(x224, Decl(generatedContextualTyping.ts, 226, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 14)) +>x224 : Symbol(x224, Decl(generatedContextualTyping.ts, 225, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x225: () => Base[]; x225 = () => [d1, d2]; ->x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3)) +>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x226: () => Base[]; x226 = function() { return [d1, d2] }; ->x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3)) +>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x227: () => Base[]; x227 = function named() { return [d1, d2] }; ->x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3)) +>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 229, 30)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 228, 30)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x228: { (): Base[]; }; x228 = () => [d1, d2]; ->x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3)) +>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x229: { (): Base[]; }; x229 = function() { return [d1, d2] }; ->x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3)) +>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] }; ->x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3)) +>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 232, 33)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 231, 33)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x231: Base[]; x231 = [d1, d2]; ->x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3)) +>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 232, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 232, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x232: Array; x232 = [d1, d2]; ->x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3)) +>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x233: { [n: number]: Base; }; x233 = [d1, d2]; ->x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 13)) +>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 234, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 234, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 234, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x234: {n: Base[]; } ; x234 = { n: [d1, d2] }; ->x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 11)) +>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; }; ->x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 237, 11)) +>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 236, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47)) +>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x236: Genric; x236 = { func: n => { return [d1, d2]; } }; ->x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 238, 32)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 237, 32)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x237: { n: () => Base[]; } = { n: () => [d1, d2] }; ->x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 239, 3)) +>x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 238, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 11)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) + +var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } }; +>x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 239, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } }; ->x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 240, 3)) +var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } }; +>x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 240, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 240, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } }; ->x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 241, 3)) +var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] }; +>x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 241, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 34)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 241, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] }; ->x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 242, 3)) +var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } }; +>x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 242, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } }; ->x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 243, 3)) +var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } }; +>x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 243, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) - -var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } }; ->x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 244, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 11)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 37)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 244, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 243, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x243: { n: Base[]; } = { n: [d1, d2] }; ->x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 245, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11)) +>x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 244, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x244: { n: Array; } = { n: [d1, d2] }; ->x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 246, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11)) +>x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 245, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 33)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 33)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] }; ->x245 : Symbol(x245, Decl(generatedContextualTyping.ts, 247, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 18)) +>x245 : Symbol(x245, Decl(generatedContextualTyping.ts, 246, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } }; ->x246 : Symbol(x246, Decl(generatedContextualTyping.ts, 248, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 16)) +>x246 : Symbol(x246, Decl(generatedContextualTyping.ts, 247, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 36)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 36)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; } }; ->x247 : Symbol(x247, Decl(generatedContextualTyping.ts, 249, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 249, 16)) +>x247 : Symbol(x247, Decl(generatedContextualTyping.ts, 248, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 248, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x248: { n: Genric; } = { n: { func: n => { return [d1, d2]; } } }; ->x248 : Symbol(x248, Decl(generatedContextualTyping.ts, 250, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x248 : Symbol(x248, Decl(generatedContextualTyping.ts, 249, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 34)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 250, 39)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 34)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 249, 39)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x252: { (): Base[]; }[] = [() => [d1, d2]]; ->x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 251, 3)) +>x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 250, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x253: { (): Base[]; }[] = [function() { return [d1, d2] }]; ->x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 252, 3)) +>x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 251, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }]; ->x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 253, 3)) +>x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 252, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 253, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 252, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x255: Base[][] = [[d1, d2]]; ->x255 : Symbol(x255, Decl(generatedContextualTyping.ts, 254, 3)) +>x255 : Symbol(x255, Decl(generatedContextualTyping.ts, 253, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x256: Array[] = [[d1, d2]]; ->x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 255, 3)) +>x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 254, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x257: { [n: number]: Base; }[] = [[d1, d2]]; ->x257 : Symbol(x257, Decl(generatedContextualTyping.ts, 256, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 13)) +>x257 : Symbol(x257, Decl(generatedContextualTyping.ts, 255, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 255, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x258: {n: Base[]; } [] = [{ n: [d1, d2] }]; ->x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 257, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 11)) +>x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 256, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x260: Genric[] = [{ func: n => { return [d1, d2]; } }]; ->x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 258, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 257, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 258, 29)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 258, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 257, 29)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x261: () => Base[] = function() { return [d1, d2] } || undefined; ->x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 259, 3)) +>x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 258, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x262: () => Base[] = function named() { return [d1, d2] } || undefined; ->x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 260, 3)) +>x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 259, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 260, 24)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 259, 24)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined; ->x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 261, 3)) +>x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 260, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined; ->x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 262, 3)) +>x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 261, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 262, 27)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 261, 27)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x265: Base[] = [d1, d2] || undefined; ->x265 : Symbol(x265, Decl(generatedContextualTyping.ts, 263, 3)) +>x265 : Symbol(x265, Decl(generatedContextualTyping.ts, 262, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x266: Array = [d1, d2] || undefined; ->x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 264, 3)) +>x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 263, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x267: { [n: number]: Base; } = [d1, d2] || undefined; ->x267 : Symbol(x267, Decl(generatedContextualTyping.ts, 265, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 13)) +>x267 : Symbol(x267, Decl(generatedContextualTyping.ts, 264, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 264, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x268: {n: Base[]; } = { n: [d1, d2] } || undefined; ->x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 266, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 11)) +>x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 265, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x269: () => Base[] = undefined || function() { return [d1, d2] }; ->x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 267, 3)) +>x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 266, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x270: () => Base[] = undefined || function named() { return [d1, d2] }; ->x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 268, 3)) +>x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 267, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 268, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 267, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x271: { (): Base[]; } = undefined || function() { return [d1, d2] }; ->x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 269, 3)) +>x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 268, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] }; ->x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 270, 3)) +>x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 269, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 270, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 269, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x273: Base[] = undefined || [d1, d2]; ->x273 : Symbol(x273, Decl(generatedContextualTyping.ts, 271, 3)) +>x273 : Symbol(x273, Decl(generatedContextualTyping.ts, 270, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x274: Array = undefined || [d1, d2]; ->x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 272, 3)) +>x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 271, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x275: { [n: number]: Base; } = undefined || [d1, d2]; ->x275 : Symbol(x275, Decl(generatedContextualTyping.ts, 273, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 13)) +>x275 : Symbol(x275, Decl(generatedContextualTyping.ts, 272, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 272, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x276: {n: Base[]; } = undefined || { n: [d1, d2] }; ->x276 : Symbol(x276, Decl(generatedContextualTyping.ts, 274, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 11)) +>x276 : Symbol(x276, Decl(generatedContextualTyping.ts, 273, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] }; ->x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 275, 3)) +>x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 274, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] }; ->x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 276, 3)) +>x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 275, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 24)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 64)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 24)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 64)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] }; ->x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 277, 3)) +>x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 276, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] }; ->x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 278, 3)) +>x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 277, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 27)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 67)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 27)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 67)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x281: Base[] = [d1, d2] || [d1, d2]; ->x281 : Symbol(x281, Decl(generatedContextualTyping.ts, 279, 3)) +>x281 : Symbol(x281, Decl(generatedContextualTyping.ts, 278, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x282: Array = [d1, d2] || [d1, d2]; ->x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 280, 3)) +>x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 279, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x283: { [n: number]: Base; } = [d1, d2] || [d1, d2]; ->x283 : Symbol(x283, Decl(generatedContextualTyping.ts, 281, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 13)) +>x283 : Symbol(x283, Decl(generatedContextualTyping.ts, 280, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 280, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x284: {n: Base[]; } = { n: [d1, d2] } || { n: [d1, d2] }; ->x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 282, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 11)) +>x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 281, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2]; ->x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 283, 3)) +>x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 282, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] }; ->x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 284, 3)) +>x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 283, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] }; ->x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 285, 3)) +>x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 284, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 70)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 70)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2]; ->x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 286, 3)) +>x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 285, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] }; ->x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 287, 3)) +>x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 286, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] }; ->x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 288, 3)) +>x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 287, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 73)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 73)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x291: Base[] = true ? [d1, d2] : [d1, d2]; ->x291 : Symbol(x291, Decl(generatedContextualTyping.ts, 289, 3)) +>x291 : Symbol(x291, Decl(generatedContextualTyping.ts, 288, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x292: Array = true ? [d1, d2] : [d1, d2]; ->x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 290, 3)) +>x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 289, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x293: { [n: number]: Base; } = true ? [d1, d2] : [d1, d2]; ->x293 : Symbol(x293, Decl(generatedContextualTyping.ts, 291, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 13)) +>x293 : Symbol(x293, Decl(generatedContextualTyping.ts, 290, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 290, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x294: {n: Base[]; } = true ? { n: [d1, d2] } : { n: [d1, d2] }; ->x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 292, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 11)) +>x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 291, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; }; ->x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 293, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 293, 11)) +>x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 292, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 292, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x296: Genric = true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } }; ->x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 294, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 33)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 71)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 77)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 293, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 33)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 71)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 77)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x297: () => Base[] = true ? undefined : () => [d1, d2]; ->x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 295, 3)) +>x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 294, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x298: () => Base[] = true ? undefined : function() { return [d1, d2] }; ->x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 296, 3)) +>x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 295, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] }; ->x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 297, 3)) +>x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 296, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 297, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 296, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x300: { (): Base[]; } = true ? undefined : () => [d1, d2]; ->x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 298, 3)) +>x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 297, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] }; ->x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 299, 3)) +>x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 298, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2] }; ->x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 300, 3)) +>x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 299, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 300, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 299, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x303: Base[] = true ? undefined : [d1, d2]; ->x303 : Symbol(x303, Decl(generatedContextualTyping.ts, 301, 3)) +>x303 : Symbol(x303, Decl(generatedContextualTyping.ts, 300, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x304: Array = true ? undefined : [d1, d2]; ->x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 302, 3)) +>x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 301, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x305: { [n: number]: Base; } = true ? undefined : [d1, d2]; ->x305 : Symbol(x305, Decl(generatedContextualTyping.ts, 303, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 13)) +>x305 : Symbol(x305, Decl(generatedContextualTyping.ts, 302, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 302, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x306: {n: Base[]; } = true ? undefined : { n: [d1, d2] }; ->x306 : Symbol(x306, Decl(generatedContextualTyping.ts, 304, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 11)) +>x306 : Symbol(x306, Decl(generatedContextualTyping.ts, 303, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return null; }; ->x307 : Symbol(x307, Decl(generatedContextualTyping.ts, 305, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 305, 11)) +>x307 : Symbol(x307, Decl(generatedContextualTyping.ts, 304, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 304, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x308: Genric = true ? undefined : { func: n => { return [d1, d2]; } }; ->x308 : Symbol(x308, Decl(generatedContextualTyping.ts, 306, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x308 : Symbol(x308, Decl(generatedContextualTyping.ts, 305, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 306, 45)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 306, 51)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 305, 45)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 51)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x309: () => Base[] = true ? () => [d1, d2] : undefined; ->x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 307, 3)) +>x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 306, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined; ->x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 308, 3)) +>x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 307, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined; ->x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 309, 3)) +>x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 308, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 309, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 308, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined; ->x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 310, 3)) +>x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 309, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined; ->x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 311, 3)) +>x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 310, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined; ->x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 312, 3)) +>x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 311, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 312, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 311, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x315: Base[] = true ? [d1, d2] : undefined; ->x315 : Symbol(x315, Decl(generatedContextualTyping.ts, 313, 3)) +>x315 : Symbol(x315, Decl(generatedContextualTyping.ts, 312, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x316: Array = true ? [d1, d2] : undefined; ->x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 314, 3)) +>x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 313, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x317: { [n: number]: Base; } = true ? [d1, d2] : undefined; ->x317 : Symbol(x317, Decl(generatedContextualTyping.ts, 315, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 13)) +>x317 : Symbol(x317, Decl(generatedContextualTyping.ts, 314, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 314, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x318: {n: Base[]; } = true ? { n: [d1, d2] } : undefined; ->x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 316, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 11)) +>x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 315, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : undefined; ->x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 317, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 317, 11)) +>x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 316, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 316, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) var x320: Genric = true ? { func: n => { return [d1, d2]; } } : undefined; ->x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 318, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 317, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 318, 33)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 317, 33)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) >undefined : Symbol(undefined) function x321(n: () => Base[]) { }; x321(() => [d1, d2]); ->x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14)) +>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] }); ->x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14)) +>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] }); ->x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14)) +>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 321, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 320, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]); ->x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14)) +>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] }); ->x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14)) +>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] }); ->x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 324, 14)) +>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 324, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 323, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x327(n: Base[]) { }; x327([d1, d2]); ->x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14)) +>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 323, 82)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 324, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 323, 82)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x328(n: Array) { }; x328([d1, d2]); ->x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 14)) +>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]); ->x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 20)) +>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 325, 50)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 325, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] }); ->x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 18)) +>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null; }); ->x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 14)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 329, 18)) +>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 14)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 328, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57)) +>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x332(n: Genric) { }; x332({ func: n => { return [d1, d2]; } }); ->x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 14)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 14)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 330, 42)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 329, 42)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]); ->x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3)) +>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12)) +>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) + +var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] }); +>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12)) ->x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] }); ->x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3)) +var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] }); +>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12)) ->x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 332, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] }); ->x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3)) +var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]); +>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12)) ->x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 333, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]); ->x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3)) +var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] }); +>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12)) ->x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] }); ->x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3)) +var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] }); +>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12)) ->x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 335, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] }); ->x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3)) +var x339 = (n: Base[]) => n; x339([d1, d2]); +>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12)) ->x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 336, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x339 = (n: Base[]) => n; x339([d1, d2]); ->x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3)) +var x340 = (n: Array) => n; x340([d1, d2]); +>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12)) ->x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x340 = (n: Array) => n; x340([d1, d2]); ->x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3)) +var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]); +>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12)) ->x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]); ->x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3)) +var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] }); +>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 18)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12)) ->x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) -var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] }); ->x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3)) +var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; }); +>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 16)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 340, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12)) ->x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) - -var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; }); ->x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 341, 16)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) ->x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56)) +>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x344 = (n: Genric) => n; x344({ func: n => { return [d1, d2]; } }); ->x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12)) ->x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 342, 41)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) +>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 341, 41)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]); ->x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20)) +>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] }); ->x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20)) +>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] }); ->x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20)) +>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 345, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 344, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]); ->x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20)) +>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] }); ->x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20)) +>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] }); ->x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20)) +>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 348, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 347, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x351 = function(n: Base[]) { }; x351([d1, d2]); ->x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20)) +>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x352 = function(n: Array) { }; x352([d1, d2]); ->x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20)) +>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]); ->x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 26)) +>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 26)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] }); ->x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 24)) +>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; return null; }); ->x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 353, 24)) +>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 352, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63)) +>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x356 = function(n: Genric) { }; x356({ func: n => { return [d1, d2]; } }); ->x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 20)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 354, 48)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 54)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 353, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 54)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) diff --git a/tests/baselines/reference/generatedContextualTyping.types b/tests/baselines/reference/generatedContextualTyping.types index a9b350f856446..d2eed9255913d 100644 --- a/tests/baselines/reference/generatedContextualTyping.types +++ b/tests/baselines/reference/generatedContextualTyping.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts === - class Base { private p; } >Base : Base >p : any diff --git a/tests/baselines/reference/generatorTypeCheck40.errors.txt b/tests/baselines/reference/generatorTypeCheck40.errors.txt index ba93862c8d538..3cc7c02fa7585 100644 --- a/tests/baselines/reference/generatorTypeCheck40.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck40.errors.txt @@ -1,12 +1,9 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts(2,21): error TS2507: Type 'any' is not a constructor function type. tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts(2,22): error TS1163: A 'yield' expression is only allowed in a generator body. -==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts (1 errors) ==== function* g() { class C extends (yield 0) { } - ~~~~~~~~~ -!!! error TS2507: Type 'any' is not a constructor function type. ~~~~~ !!! error TS1163: A 'yield' expression is only allowed in a generator body. } \ No newline at end of file diff --git a/tests/baselines/reference/generatorTypeCheck47.errors.txt b/tests/baselines/reference/generatorTypeCheck47.errors.txt index f5264f7ce9607..993285179bcaa 100644 --- a/tests/baselines/reference/generatorTypeCheck47.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck47.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts(2,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts(1,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts (1 errors) ==== - function* g() { } ~ !!! error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. \ No newline at end of file diff --git a/tests/baselines/reference/generatorTypeCheck47.js b/tests/baselines/reference/generatorTypeCheck47.js index b06fb96b43513..003f195c2210c 100644 --- a/tests/baselines/reference/generatorTypeCheck47.js +++ b/tests/baselines/reference/generatorTypeCheck47.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck47.ts] - function* g() { } //// [generatorTypeCheck47.js] diff --git a/tests/baselines/reference/generatorTypeCheck48.errors.txt b/tests/baselines/reference/generatorTypeCheck48.errors.txt index c91626cd813cb..867a0c35f6045 100644 --- a/tests/baselines/reference/generatorTypeCheck48.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck48.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts(2,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts(1,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts (1 errors) ==== - function* g() { ~ !!! error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. diff --git a/tests/baselines/reference/generatorTypeCheck48.js b/tests/baselines/reference/generatorTypeCheck48.js index 579d6dcf0e1ca..f4ce9fbb3345d 100644 --- a/tests/baselines/reference/generatorTypeCheck48.js +++ b/tests/baselines/reference/generatorTypeCheck48.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck48.ts] - function* g() { yield; } diff --git a/tests/baselines/reference/generatorTypeCheck49.js b/tests/baselines/reference/generatorTypeCheck49.js index b544c7e422535..aec462ca553f9 100644 --- a/tests/baselines/reference/generatorTypeCheck49.js +++ b/tests/baselines/reference/generatorTypeCheck49.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck49.ts] - function* g() { yield 0; } diff --git a/tests/baselines/reference/generatorTypeCheck49.symbols b/tests/baselines/reference/generatorTypeCheck49.symbols index d24deed3d803d..3e0cedad0fd62 100644 --- a/tests/baselines/reference/generatorTypeCheck49.symbols +++ b/tests/baselines/reference/generatorTypeCheck49.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts === - function* g() { >g : Symbol(g, Decl(generatorTypeCheck49.ts, 0, 0)) diff --git a/tests/baselines/reference/generatorTypeCheck49.types b/tests/baselines/reference/generatorTypeCheck49.types index cd9f3e82d0987..6ac2b6acce861 100644 --- a/tests/baselines/reference/generatorTypeCheck49.types +++ b/tests/baselines/reference/generatorTypeCheck49.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts === - function* g() { >g : () => IterableIterator<0> diff --git a/tests/baselines/reference/generatorTypeCheck50.js b/tests/baselines/reference/generatorTypeCheck50.js index 856e3867ab6bc..44e072c4b5e76 100644 --- a/tests/baselines/reference/generatorTypeCheck50.js +++ b/tests/baselines/reference/generatorTypeCheck50.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck50.ts] - function* g() { yield yield; } diff --git a/tests/baselines/reference/generatorTypeCheck50.symbols b/tests/baselines/reference/generatorTypeCheck50.symbols index 412a1ac1ea7cc..636de9b40d9c6 100644 --- a/tests/baselines/reference/generatorTypeCheck50.symbols +++ b/tests/baselines/reference/generatorTypeCheck50.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts === - function* g() { >g : Symbol(g, Decl(generatorTypeCheck50.ts, 0, 0)) diff --git a/tests/baselines/reference/generatorTypeCheck50.types b/tests/baselines/reference/generatorTypeCheck50.types index 342d7406dce0e..1b25ea004f8fb 100644 --- a/tests/baselines/reference/generatorTypeCheck50.types +++ b/tests/baselines/reference/generatorTypeCheck50.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts === - function* g() { >g : () => IterableIterator diff --git a/tests/baselines/reference/generatorTypeCheck51.errors.txt b/tests/baselines/reference/generatorTypeCheck51.errors.txt index f4fc5723a5ece..b717b51803e38 100644 --- a/tests/baselines/reference/generatorTypeCheck51.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck51.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts(2,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts(1,9): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts (1 errors) ==== - function* g() { ~ !!! error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. diff --git a/tests/baselines/reference/generatorTypeCheck51.js b/tests/baselines/reference/generatorTypeCheck51.js index f3519065c3d25..1df4d23e2d3f1 100644 --- a/tests/baselines/reference/generatorTypeCheck51.js +++ b/tests/baselines/reference/generatorTypeCheck51.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck51.ts] - function* g() { function* h() { yield 0; diff --git a/tests/baselines/reference/generatorTypeCheck55.errors.txt b/tests/baselines/reference/generatorTypeCheck55.errors.txt index 854c1801efddc..7856a0074ffde 100644 --- a/tests/baselines/reference/generatorTypeCheck55.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck55.errors.txt @@ -1,12 +1,9 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts(2,29): error TS2507: Type 'any' is not a constructor function type. tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts(2,30): error TS1163: A 'yield' expression is only allowed in a generator body. -==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts (1 errors) ==== function* g() { var x = class C extends (yield) {}; - ~~~~~~~ -!!! error TS2507: Type 'any' is not a constructor function type. ~~~~~ !!! error TS1163: A 'yield' expression is only allowed in a generator body. } \ No newline at end of file diff --git a/tests/baselines/reference/generatorTypeCheck60.errors.txt b/tests/baselines/reference/generatorTypeCheck60.errors.txt index 5330cd186b704..6f7bf465804d6 100644 --- a/tests/baselines/reference/generatorTypeCheck60.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck60.errors.txt @@ -1,12 +1,9 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts(2,21): error TS2507: Type 'any' is not a constructor function type. tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts(2,22): error TS1163: A 'yield' expression is only allowed in a generator body. -==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts (1 errors) ==== function* g() { class C extends (yield) {}; - ~~~~~~~ -!!! error TS2507: Type 'any' is not a constructor function type. ~~~~~ !!! error TS1163: A 'yield' expression is only allowed in a generator body. } \ No newline at end of file diff --git a/tests/baselines/reference/generatorTypeCheck62.js b/tests/baselines/reference/generatorTypeCheck62.js index 30864722210d1..e87e2d494be8a 100644 --- a/tests/baselines/reference/generatorTypeCheck62.js +++ b/tests/baselines/reference/generatorTypeCheck62.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck62.ts] - export interface StrategicState { lastStrategyApplied?: string; } diff --git a/tests/baselines/reference/generatorTypeCheck62.symbols b/tests/baselines/reference/generatorTypeCheck62.symbols index 580ab20884009..b8eb11d1f6743 100644 --- a/tests/baselines/reference/generatorTypeCheck62.symbols +++ b/tests/baselines/reference/generatorTypeCheck62.symbols @@ -1,106 +1,105 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck62.ts === - export interface StrategicState { >StrategicState : Symbol(StrategicState, Decl(generatorTypeCheck62.ts, 0, 0)) lastStrategyApplied?: string; ->lastStrategyApplied : Symbol(StrategicState.lastStrategyApplied, Decl(generatorTypeCheck62.ts, 1, 33)) +>lastStrategyApplied : Symbol(StrategicState.lastStrategyApplied, Decl(generatorTypeCheck62.ts, 0, 33)) } export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { ->strategy : Symbol(strategy, Decl(generatorTypeCheck62.ts, 3, 1)) ->T : Symbol(T, Decl(generatorTypeCheck62.ts, 5, 25)) +>strategy : Symbol(strategy, Decl(generatorTypeCheck62.ts, 2, 1)) +>T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) >StrategicState : Symbol(StrategicState, Decl(generatorTypeCheck62.ts, 0, 0)) ->stratName : Symbol(stratName, Decl(generatorTypeCheck62.ts, 5, 51)) ->gen : Symbol(gen, Decl(generatorTypeCheck62.ts, 5, 69)) ->a : Symbol(a, Decl(generatorTypeCheck62.ts, 5, 76)) ->T : Symbol(T, Decl(generatorTypeCheck62.ts, 5, 25)) +>stratName : Symbol(stratName, Decl(generatorTypeCheck62.ts, 4, 51)) +>gen : Symbol(gen, Decl(generatorTypeCheck62.ts, 4, 69)) +>a : Symbol(a, Decl(generatorTypeCheck62.ts, 4, 76)) +>T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(generatorTypeCheck62.ts, 5, 25)) ->a : Symbol(a, Decl(generatorTypeCheck62.ts, 5, 120)) ->T : Symbol(T, Decl(generatorTypeCheck62.ts, 5, 25)) +>T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) +>a : Symbol(a, Decl(generatorTypeCheck62.ts, 4, 120)) +>T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(generatorTypeCheck62.ts, 5, 25)) +>T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) return function*(state) { ->state : Symbol(state, Decl(generatorTypeCheck62.ts, 6, 21)) +>state : Symbol(state, Decl(generatorTypeCheck62.ts, 5, 21)) for (const next of gen(state)) { ->next : Symbol(next, Decl(generatorTypeCheck62.ts, 7, 18)) ->gen : Symbol(gen, Decl(generatorTypeCheck62.ts, 5, 69)) ->state : Symbol(state, Decl(generatorTypeCheck62.ts, 6, 21)) +>next : Symbol(next, Decl(generatorTypeCheck62.ts, 6, 18)) +>gen : Symbol(gen, Decl(generatorTypeCheck62.ts, 4, 69)) +>state : Symbol(state, Decl(generatorTypeCheck62.ts, 5, 21)) if (next) { ->next : Symbol(next, Decl(generatorTypeCheck62.ts, 7, 18)) +>next : Symbol(next, Decl(generatorTypeCheck62.ts, 6, 18)) next.lastStrategyApplied = stratName; ->next.lastStrategyApplied : Symbol(StrategicState.lastStrategyApplied, Decl(generatorTypeCheck62.ts, 1, 33)) ->next : Symbol(next, Decl(generatorTypeCheck62.ts, 7, 18)) ->lastStrategyApplied : Symbol(StrategicState.lastStrategyApplied, Decl(generatorTypeCheck62.ts, 1, 33)) ->stratName : Symbol(stratName, Decl(generatorTypeCheck62.ts, 5, 51)) +>next.lastStrategyApplied : Symbol(StrategicState.lastStrategyApplied, Decl(generatorTypeCheck62.ts, 0, 33)) +>next : Symbol(next, Decl(generatorTypeCheck62.ts, 6, 18)) +>lastStrategyApplied : Symbol(StrategicState.lastStrategyApplied, Decl(generatorTypeCheck62.ts, 0, 33)) +>stratName : Symbol(stratName, Decl(generatorTypeCheck62.ts, 4, 51)) } yield next; ->next : Symbol(next, Decl(generatorTypeCheck62.ts, 7, 18)) +>next : Symbol(next, Decl(generatorTypeCheck62.ts, 6, 18)) } } } export interface Strategy { ->Strategy : Symbol(Strategy, Decl(generatorTypeCheck62.ts, 14, 1)) ->T : Symbol(T, Decl(generatorTypeCheck62.ts, 16, 26)) +>Strategy : Symbol(Strategy, Decl(generatorTypeCheck62.ts, 13, 1)) +>T : Symbol(T, Decl(generatorTypeCheck62.ts, 15, 26)) (a: T): IterableIterator; ->a : Symbol(a, Decl(generatorTypeCheck62.ts, 17, 5)) ->T : Symbol(T, Decl(generatorTypeCheck62.ts, 16, 26)) +>a : Symbol(a, Decl(generatorTypeCheck62.ts, 16, 5)) +>T : Symbol(T, Decl(generatorTypeCheck62.ts, 15, 26)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(generatorTypeCheck62.ts, 16, 26)) +>T : Symbol(T, Decl(generatorTypeCheck62.ts, 15, 26)) } export interface State extends StrategicState { ->State : Symbol(State, Decl(generatorTypeCheck62.ts, 18, 1)) +>State : Symbol(State, Decl(generatorTypeCheck62.ts, 17, 1)) >StrategicState : Symbol(StrategicState, Decl(generatorTypeCheck62.ts, 0, 0)) foo: number; ->foo : Symbol(State.foo, Decl(generatorTypeCheck62.ts, 20, 47)) +>foo : Symbol(State.foo, Decl(generatorTypeCheck62.ts, 19, 47)) } export const Nothing1: Strategy = strategy("Nothing", function*(state: State) { ->Nothing1 : Symbol(Nothing1, Decl(generatorTypeCheck62.ts, 24, 12)) ->Strategy : Symbol(Strategy, Decl(generatorTypeCheck62.ts, 14, 1)) ->State : Symbol(State, Decl(generatorTypeCheck62.ts, 18, 1)) ->strategy : Symbol(strategy, Decl(generatorTypeCheck62.ts, 3, 1)) ->state : Symbol(state, Decl(generatorTypeCheck62.ts, 24, 71)) ->State : Symbol(State, Decl(generatorTypeCheck62.ts, 18, 1)) +>Nothing1 : Symbol(Nothing1, Decl(generatorTypeCheck62.ts, 23, 12)) +>Strategy : Symbol(Strategy, Decl(generatorTypeCheck62.ts, 13, 1)) +>State : Symbol(State, Decl(generatorTypeCheck62.ts, 17, 1)) +>strategy : Symbol(strategy, Decl(generatorTypeCheck62.ts, 2, 1)) +>state : Symbol(state, Decl(generatorTypeCheck62.ts, 23, 71)) +>State : Symbol(State, Decl(generatorTypeCheck62.ts, 17, 1)) return state; ->state : Symbol(state, Decl(generatorTypeCheck62.ts, 24, 71)) +>state : Symbol(state, Decl(generatorTypeCheck62.ts, 23, 71)) }); export const Nothing2: Strategy = strategy("Nothing", function*(state: State) { ->Nothing2 : Symbol(Nothing2, Decl(generatorTypeCheck62.ts, 28, 12)) ->Strategy : Symbol(Strategy, Decl(generatorTypeCheck62.ts, 14, 1)) ->State : Symbol(State, Decl(generatorTypeCheck62.ts, 18, 1)) ->strategy : Symbol(strategy, Decl(generatorTypeCheck62.ts, 3, 1)) ->state : Symbol(state, Decl(generatorTypeCheck62.ts, 28, 71)) ->State : Symbol(State, Decl(generatorTypeCheck62.ts, 18, 1)) +>Nothing2 : Symbol(Nothing2, Decl(generatorTypeCheck62.ts, 27, 12)) +>Strategy : Symbol(Strategy, Decl(generatorTypeCheck62.ts, 13, 1)) +>State : Symbol(State, Decl(generatorTypeCheck62.ts, 17, 1)) +>strategy : Symbol(strategy, Decl(generatorTypeCheck62.ts, 2, 1)) +>state : Symbol(state, Decl(generatorTypeCheck62.ts, 27, 71)) +>State : Symbol(State, Decl(generatorTypeCheck62.ts, 17, 1)) yield state; ->state : Symbol(state, Decl(generatorTypeCheck62.ts, 28, 71)) +>state : Symbol(state, Decl(generatorTypeCheck62.ts, 27, 71)) }); export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { ->Nothing3 : Symbol(Nothing3, Decl(generatorTypeCheck62.ts, 32, 12)) ->Strategy : Symbol(Strategy, Decl(generatorTypeCheck62.ts, 14, 1)) ->State : Symbol(State, Decl(generatorTypeCheck62.ts, 18, 1)) ->strategy : Symbol(strategy, Decl(generatorTypeCheck62.ts, 3, 1)) ->state : Symbol(state, Decl(generatorTypeCheck62.ts, 32, 72)) ->State : Symbol(State, Decl(generatorTypeCheck62.ts, 18, 1)) +>Nothing3 : Symbol(Nothing3, Decl(generatorTypeCheck62.ts, 31, 12)) +>Strategy : Symbol(Strategy, Decl(generatorTypeCheck62.ts, 13, 1)) +>State : Symbol(State, Decl(generatorTypeCheck62.ts, 17, 1)) +>strategy : Symbol(strategy, Decl(generatorTypeCheck62.ts, 2, 1)) +>state : Symbol(state, Decl(generatorTypeCheck62.ts, 31, 72)) +>State : Symbol(State, Decl(generatorTypeCheck62.ts, 17, 1)) yield ; return state; ->state : Symbol(state, Decl(generatorTypeCheck62.ts, 32, 72)) +>state : Symbol(state, Decl(generatorTypeCheck62.ts, 31, 72)) }); diff --git a/tests/baselines/reference/generatorTypeCheck62.types b/tests/baselines/reference/generatorTypeCheck62.types index 289d33dc7d44e..f8b3a9117b137 100644 --- a/tests/baselines/reference/generatorTypeCheck62.types +++ b/tests/baselines/reference/generatorTypeCheck62.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck62.ts === - export interface StrategicState { >StrategicState : StrategicState diff --git a/tests/baselines/reference/generatorTypeCheck63.errors.txt b/tests/baselines/reference/generatorTypeCheck63.errors.txt index 46e722a0dd144..ed2ed36a438da 100644 --- a/tests/baselines/reference/generatorTypeCheck63.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck63.errors.txt @@ -1,15 +1,14 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(25,14): error TS2322: Type '(a: State | 1) => IterableIterator' is not assignable to type 'Strategy'. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(24,14): error TS2322: Type '(a: State | 1) => IterableIterator' is not assignable to type 'Strategy'. Type 'IterableIterator' is not assignable to type 'IterableIterator'. Type 'State | 1' is not assignable to type 'State'. Type '1' is not assignable to type 'State'. -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(30,70): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(33,42): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(29,70): error TS7025: Generator implicitly has type 'IterableIterator' because it does not yield any values. Consider supplying a return type. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(32,42): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'State' is not a valid type argument because it is not a supertype of candidate '1'. -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(37,14): error TS2322: Type '(a: State | 1) => IterableIterator' is not assignable to type 'Strategy'. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(36,14): error TS2322: Type '(a: State | 1) => IterableIterator' is not assignable to type 'Strategy'. ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts (4 errors) ==== - export interface StrategicState { lastStrategyApplied?: string; } diff --git a/tests/baselines/reference/generatorTypeCheck63.js b/tests/baselines/reference/generatorTypeCheck63.js index 92cf2f867fcb2..d19d18fb1df40 100644 --- a/tests/baselines/reference/generatorTypeCheck63.js +++ b/tests/baselines/reference/generatorTypeCheck63.js @@ -1,5 +1,4 @@ //// [generatorTypeCheck63.ts] - export interface StrategicState { lastStrategyApplied?: string; } diff --git a/tests/baselines/reference/genericArray0.js b/tests/baselines/reference/genericArray0.js index a6a4f9365d1d4..d288f18a99503 100644 --- a/tests/baselines/reference/genericArray0.js +++ b/tests/baselines/reference/genericArray0.js @@ -1,6 +1,5 @@ //// [genericArray0.ts] - var x:number[]; diff --git a/tests/baselines/reference/genericArray0.symbols b/tests/baselines/reference/genericArray0.symbols index 8870d60cde8b4..b757cbf348cdc 100644 --- a/tests/baselines/reference/genericArray0.symbols +++ b/tests/baselines/reference/genericArray0.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/genericArray0.ts === - var x:number[]; ->x : Symbol(x, Decl(genericArray0.ts, 2, 3)) +>x : Symbol(x, Decl(genericArray0.ts, 1, 3)) var y = x; ->y : Symbol(y, Decl(genericArray0.ts, 5, 3)) ->x : Symbol(x, Decl(genericArray0.ts, 2, 3)) +>y : Symbol(y, Decl(genericArray0.ts, 4, 3)) +>x : Symbol(x, Decl(genericArray0.ts, 1, 3)) function map() { ->map : Symbol(map, Decl(genericArray0.ts, 5, 10)) ->U : Symbol(U, Decl(genericArray0.ts, 7, 13)) +>map : Symbol(map, Decl(genericArray0.ts, 4, 10)) +>U : Symbol(U, Decl(genericArray0.ts, 6, 13)) var ys: U[] = []; ->ys : Symbol(ys, Decl(genericArray0.ts, 8, 7)) ->U : Symbol(U, Decl(genericArray0.ts, 7, 13)) +>ys : Symbol(ys, Decl(genericArray0.ts, 7, 7)) +>U : Symbol(U, Decl(genericArray0.ts, 6, 13)) } diff --git a/tests/baselines/reference/genericArray0.types b/tests/baselines/reference/genericArray0.types index bf0155bb9ba66..0583049c96580 100644 --- a/tests/baselines/reference/genericArray0.types +++ b/tests/baselines/reference/genericArray0.types @@ -1,6 +1,5 @@ === tests/cases/compiler/genericArray0.ts === - var x:number[]; >x : number[] diff --git a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt index 428ebecf5b0ec..9f728e554a364 100644 --- a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt +++ b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt @@ -1,19 +1,18 @@ -tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(24,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. +tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(23,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(53,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. +tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(52,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(69,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. +tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(68,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(85,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; (b: boolean): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. +tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts(84,38): error TS2345: Argument of type '{ (n: number): Promise; (s: string): Promise; (b: boolean): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'boolean'. ==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts (4 errors) ==== - module m1 { interface Promise { then(cb: (x: T) => Promise): Promise; diff --git a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js index 9bfb6eec1135b..42ba2b3233c43 100644 --- a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js +++ b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js @@ -1,5 +1,4 @@ //// [genericCallToOverloadedMethodWithOverloadedArguments.ts] - module m1 { interface Promise { then(cb: (x: T) => Promise): Promise; diff --git a/tests/baselines/reference/genericClassesInModule.js b/tests/baselines/reference/genericClassesInModule.js index e531e25ec7af4..6ca65804d8907 100644 --- a/tests/baselines/reference/genericClassesInModule.js +++ b/tests/baselines/reference/genericClassesInModule.js @@ -1,5 +1,4 @@ //// [genericClassesInModule.ts] - module Foo { export class B{ } diff --git a/tests/baselines/reference/genericClassesInModule.symbols b/tests/baselines/reference/genericClassesInModule.symbols index f097eac36f1fa..ac3a0eca4a2ff 100644 --- a/tests/baselines/reference/genericClassesInModule.symbols +++ b/tests/baselines/reference/genericClassesInModule.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/genericClassesInModule.ts === - module Foo { >Foo : Symbol(Foo, Decl(genericClassesInModule.ts, 0, 0)) export class B{ } ->B : Symbol(B, Decl(genericClassesInModule.ts, 1, 12)) ->T : Symbol(T, Decl(genericClassesInModule.ts, 3, 19)) +>B : Symbol(B, Decl(genericClassesInModule.ts, 0, 12)) +>T : Symbol(T, Decl(genericClassesInModule.ts, 2, 19)) export class A { } ->A : Symbol(A, Decl(genericClassesInModule.ts, 3, 24)) +>A : Symbol(A, Decl(genericClassesInModule.ts, 2, 24)) } var a = new Foo.B(); ->a : Symbol(a, Decl(genericClassesInModule.ts, 8, 3)) ->Foo.B : Symbol(Foo.B, Decl(genericClassesInModule.ts, 1, 12)) +>a : Symbol(a, Decl(genericClassesInModule.ts, 7, 3)) +>Foo.B : Symbol(Foo.B, Decl(genericClassesInModule.ts, 0, 12)) >Foo : Symbol(Foo, Decl(genericClassesInModule.ts, 0, 0)) ->B : Symbol(Foo.B, Decl(genericClassesInModule.ts, 1, 12)) +>B : Symbol(Foo.B, Decl(genericClassesInModule.ts, 0, 12)) >Foo : Symbol(Foo, Decl(genericClassesInModule.ts, 0, 0)) ->A : Symbol(Foo.A, Decl(genericClassesInModule.ts, 3, 24)) +>A : Symbol(Foo.A, Decl(genericClassesInModule.ts, 2, 24)) diff --git a/tests/baselines/reference/genericClassesInModule.types b/tests/baselines/reference/genericClassesInModule.types index 128decac57077..819a1f302563a 100644 --- a/tests/baselines/reference/genericClassesInModule.types +++ b/tests/baselines/reference/genericClassesInModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/genericClassesInModule.ts === - module Foo { >Foo : typeof Foo diff --git a/tests/baselines/reference/genericDefaults.types b/tests/baselines/reference/genericDefaults.types index cd6c2d58e4acf..ef97847cc7369 100644 --- a/tests/baselines/reference/genericDefaults.types +++ b/tests/baselines/reference/genericDefaults.types @@ -1094,7 +1094,7 @@ declare function f12(a?: T, b?: U): [T, U]; // inference f12(); ->f12() : [{}, {} & B] +>f12() : [{}, B] >f12 : (a?: T, b?: U) => [T, U] f12(a); @@ -1856,7 +1856,7 @@ declare function f19(a?: T, b?: U): [T, U]; // inference f19(); ->f19() : [{}, {} & B] +>f19() : [{}, B] >f19 : (a?: T, b?: U) => [T, U] f19(a); @@ -1950,11 +1950,11 @@ declare function f20(a?: T, b?: U, c?: V): [T, U, V]; // inference f20(); ->f20() : [{}, {}, {} & C] +>f20() : [{}, {}, C] >f20 : (a?: T, b?: U, c?: V) => [T, U, V] f20(a); ->f20(a) : [A, {}, {} & C] +>f20(a) : [A, {}, C] >f20 : (a?: T, b?: U, c?: V) => [T, U, V] >a : A @@ -1973,25 +1973,25 @@ f20(a, b, c); // no inference, partially supplied f20(); ->f20() : [A, {}, {} & C] +>f20() : [A, {}, C] >f20 : (a?: T, b?: U, c?: V) => [T, U, V] >A : A f20(a); ->f20(a) : [A, {}, {} & C] +>f20(a) : [A, {}, C] >f20 : (a?: T, b?: U, c?: V) => [T, U, V] >A : A >a : A f20(a, b); ->f20(a, b) : [A, {}, {} & C] +>f20(a, b) : [A, {}, C] >f20 : (a?: T, b?: U, c?: V) => [T, U, V] >A : A >a : A >b : B f20(a, b, bc); ->f20(a, b, bc) : [A, {}, {} & C] +>f20(a, b, bc) : [A, {}, C] >f20 : (a?: T, b?: U, c?: V) => [T, U, V] >A : A >a : A diff --git a/tests/baselines/reference/genericDefaultsErrors.errors.txt b/tests/baselines/reference/genericDefaultsErrors.errors.txt index 03769586b413f..3d792f022ac1d 100644 --- a/tests/baselines/reference/genericDefaultsErrors.errors.txt +++ b/tests/baselines/reference/genericDefaultsErrors.errors.txt @@ -1,30 +1,29 @@ -tests/cases/compiler/genericDefaultsErrors.ts(4,41): error TS2344: Type 'number' does not satisfy the constraint 'string'. -tests/cases/compiler/genericDefaultsErrors.ts(5,59): error TS2344: Type 'T' does not satisfy the constraint 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(3,41): error TS2344: Type 'number' does not satisfy the constraint 'string'. +tests/cases/compiler/genericDefaultsErrors.ts(4,59): error TS2344: Type 'T' does not satisfy the constraint 'number'. Type 'string' is not assignable to type 'number'. -tests/cases/compiler/genericDefaultsErrors.ts(6,44): error TS2344: Type 'T' does not satisfy the constraint 'number'. -tests/cases/compiler/genericDefaultsErrors.ts(7,39): error TS2344: Type 'number' does not satisfy the constraint 'T'. -tests/cases/compiler/genericDefaultsErrors.ts(11,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/genericDefaultsErrors.ts(14,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/genericDefaultsErrors.ts(18,13): error TS2345: Argument of type '"a"' is not assignable to parameter of type 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(5,44): error TS2344: Type 'T' does not satisfy the constraint 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(6,39): error TS2344: Type 'number' does not satisfy the constraint 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(10,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/genericDefaultsErrors.ts(13,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/genericDefaultsErrors.ts(17,13): error TS2345: Argument of type '"a"' is not assignable to parameter of type 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(19,11): error TS2428: All declarations of 'i00' must have identical type parameters. tests/cases/compiler/genericDefaultsErrors.ts(20,11): error TS2428: All declarations of 'i00' must have identical type parameters. -tests/cases/compiler/genericDefaultsErrors.ts(21,11): error TS2428: All declarations of 'i00' must have identical type parameters. +tests/cases/compiler/genericDefaultsErrors.ts(22,11): error TS2428: All declarations of 'i01' must have identical type parameters. tests/cases/compiler/genericDefaultsErrors.ts(23,11): error TS2428: All declarations of 'i01' must have identical type parameters. -tests/cases/compiler/genericDefaultsErrors.ts(24,11): error TS2428: All declarations of 'i01' must have identical type parameters. -tests/cases/compiler/genericDefaultsErrors.ts(26,27): error TS2706: Required type parameters may not follow optional type parameters. -tests/cases/compiler/genericDefaultsErrors.ts(27,34): error TS2344: Type 'number' does not satisfy the constraint 'string'. -tests/cases/compiler/genericDefaultsErrors.ts(28,52): error TS2344: Type 'T' does not satisfy the constraint 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(25,27): error TS2706: Required type parameters may not follow optional type parameters. +tests/cases/compiler/genericDefaultsErrors.ts(26,34): error TS2344: Type 'number' does not satisfy the constraint 'string'. +tests/cases/compiler/genericDefaultsErrors.ts(27,52): error TS2344: Type 'T' does not satisfy the constraint 'number'. Type 'string' is not assignable to type 'number'. -tests/cases/compiler/genericDefaultsErrors.ts(29,37): error TS2344: Type 'T' does not satisfy the constraint 'number'. -tests/cases/compiler/genericDefaultsErrors.ts(30,32): error TS2344: Type 'number' does not satisfy the constraint 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(28,37): error TS2344: Type 'T' does not satisfy the constraint 'number'. +tests/cases/compiler/genericDefaultsErrors.ts(29,32): error TS2344: Type 'number' does not satisfy the constraint 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(32,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. tests/cases/compiler/genericDefaultsErrors.ts(33,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. -tests/cases/compiler/genericDefaultsErrors.ts(34,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. -tests/cases/compiler/genericDefaultsErrors.ts(37,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. -tests/cases/compiler/genericDefaultsErrors.ts(39,20): error TS2304: Cannot find name 'T'. -tests/cases/compiler/genericDefaultsErrors.ts(39,20): error TS4033: Property 'x' of exported interface has or is using private name 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(36,15): error TS2707: Generic type 'i09' requires between 2 and 3 type arguments. +tests/cases/compiler/genericDefaultsErrors.ts(38,20): error TS2304: Cannot find name 'T'. +tests/cases/compiler/genericDefaultsErrors.ts(38,20): error TS4033: Property 'x' of exported interface has or is using private name 'T'. ==== tests/cases/compiler/genericDefaultsErrors.ts (21 errors) ==== - declare const x: any; declare function f03(): void; // error diff --git a/tests/baselines/reference/genericDefaultsErrors.js b/tests/baselines/reference/genericDefaultsErrors.js index 6309b01cab3fc..c737644e99959 100644 --- a/tests/baselines/reference/genericDefaultsErrors.js +++ b/tests/baselines/reference/genericDefaultsErrors.js @@ -1,5 +1,4 @@ //// [genericDefaultsErrors.ts] - declare const x: any; declare function f03(): void; // error diff --git a/tests/baselines/reference/genericDefaultsJs.symbols b/tests/baselines/reference/genericDefaultsJs.symbols new file mode 100644 index 0000000000000..633e4cc8fe980 --- /dev/null +++ b/tests/baselines/reference/genericDefaultsJs.symbols @@ -0,0 +1,226 @@ +=== tests/cases/compiler/decls.d.ts === +declare function f0(x?: T): T; +>f0 : Symbol(f0, Decl(decls.d.ts, 0, 0)) +>T : Symbol(T, Decl(decls.d.ts, 0, 20)) +>x : Symbol(x, Decl(decls.d.ts, 0, 23)) +>T : Symbol(T, Decl(decls.d.ts, 0, 20)) +>T : Symbol(T, Decl(decls.d.ts, 0, 20)) + +declare function f1(x?: T): [T, U]; +>f1 : Symbol(f1, Decl(decls.d.ts, 0, 33)) +>T : Symbol(T, Decl(decls.d.ts, 1, 20)) +>U : Symbol(U, Decl(decls.d.ts, 1, 22)) +>x : Symbol(x, Decl(decls.d.ts, 1, 35)) +>T : Symbol(T, Decl(decls.d.ts, 1, 20)) +>T : Symbol(T, Decl(decls.d.ts, 1, 20)) +>U : Symbol(U, Decl(decls.d.ts, 1, 22)) + +declare class C0 { +>C0 : Symbol(C0, Decl(decls.d.ts, 1, 50)) +>T : Symbol(T, Decl(decls.d.ts, 2, 17)) + + y: T; +>y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) +>T : Symbol(T, Decl(decls.d.ts, 2, 17)) + + constructor(x?: T); +>x : Symbol(x, Decl(decls.d.ts, 4, 16)) +>T : Symbol(T, Decl(decls.d.ts, 2, 17)) +} +declare class C1 { +>C1 : Symbol(C1, Decl(decls.d.ts, 5, 1)) +>T : Symbol(T, Decl(decls.d.ts, 6, 17)) +>U : Symbol(U, Decl(decls.d.ts, 6, 19)) + + y: [T, U]; +>y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) +>T : Symbol(T, Decl(decls.d.ts, 6, 17)) +>U : Symbol(U, Decl(decls.d.ts, 6, 19)) + + constructor(x?: T); +>x : Symbol(x, Decl(decls.d.ts, 8, 16)) +>T : Symbol(T, Decl(decls.d.ts, 6, 17)) +} +=== tests/cases/compiler/main.js === +const f0_v0 = f0(); +>f0_v0 : Symbol(f0_v0, Decl(main.js, 0, 5)) +>f0 : Symbol(f0, Decl(decls.d.ts, 0, 0)) + +const f0_v1 = f0(1); +>f0_v1 : Symbol(f0_v1, Decl(main.js, 1, 5)) +>f0 : Symbol(f0, Decl(decls.d.ts, 0, 0)) + +const f1_c0 = f1(); +>f1_c0 : Symbol(f1_c0, Decl(main.js, 3, 5)) +>f1 : Symbol(f1, Decl(decls.d.ts, 0, 33)) + +const f1_c1 = f1(1); +>f1_c1 : Symbol(f1_c1, Decl(main.js, 4, 5)) +>f1 : Symbol(f1, Decl(decls.d.ts, 0, 33)) + +const C0_v0 = new C0(); +>C0_v0 : Symbol(C0_v0, Decl(main.js, 6, 5)) +>C0 : Symbol(C0, Decl(decls.d.ts, 1, 50)) + +const C0_v0_y = C0_v0.y; +>C0_v0_y : Symbol(C0_v0_y, Decl(main.js, 7, 5)) +>C0_v0.y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) +>C0_v0 : Symbol(C0_v0, Decl(main.js, 6, 5)) +>y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) + +const C0_v1 = new C0(1); +>C0_v1 : Symbol(C0_v1, Decl(main.js, 9, 5)) +>C0 : Symbol(C0, Decl(decls.d.ts, 1, 50)) + +const C0_v1_y = C0_v1.y; +>C0_v1_y : Symbol(C0_v1_y, Decl(main.js, 10, 5)) +>C0_v1.y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) +>C0_v1 : Symbol(C0_v1, Decl(main.js, 9, 5)) +>y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) + +const C1_v0 = new C1(); +>C1_v0 : Symbol(C1_v0, Decl(main.js, 12, 5)) +>C1 : Symbol(C1, Decl(decls.d.ts, 5, 1)) + +const C1_v0_y = C1_v0.y; +>C1_v0_y : Symbol(C1_v0_y, Decl(main.js, 13, 5)) +>C1_v0.y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) +>C1_v0 : Symbol(C1_v0, Decl(main.js, 12, 5)) +>y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) + +const C1_v1 = new C1(1); +>C1_v1 : Symbol(C1_v1, Decl(main.js, 15, 5)) +>C1 : Symbol(C1, Decl(decls.d.ts, 5, 1)) + +const C1_v1_y = C1_v1.y; +>C1_v1_y : Symbol(C1_v1_y, Decl(main.js, 16, 5)) +>C1_v1.y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) +>C1_v1 : Symbol(C1_v1, Decl(main.js, 15, 5)) +>y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) + +class C0_B0 extends C0 {} +>C0_B0 : Symbol(C0_B0, Decl(main.js, 16, 24)) +>C0 : Symbol(C0, Decl(decls.d.ts, 1, 50)) + +class C0_B1 extends C0 { +>C0_B1 : Symbol(C0_B1, Decl(main.js, 18, 25)) +>C0 : Symbol(C0, Decl(decls.d.ts, 1, 50)) + + constructor() { + super(); +>super : Symbol(C0, Decl(decls.d.ts, 1, 50)) + } +} +class C0_B2 extends C0 { +>C0_B2 : Symbol(C0_B2, Decl(main.js, 23, 1)) +>C0 : Symbol(C0, Decl(decls.d.ts, 1, 50)) + + constructor() { + super(1); +>super : Symbol(C0, Decl(decls.d.ts, 1, 50)) + } +} + +const C0_B0_v0 = new C0_B0(); +>C0_B0_v0 : Symbol(C0_B0_v0, Decl(main.js, 30, 5)) +>C0_B0 : Symbol(C0_B0, Decl(main.js, 16, 24)) + +const C0_B0_v0_y = C0_B0_v0.y; +>C0_B0_v0_y : Symbol(C0_B0_v0_y, Decl(main.js, 31, 5)) +>C0_B0_v0.y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) +>C0_B0_v0 : Symbol(C0_B0_v0, Decl(main.js, 30, 5)) +>y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) + +const C0_B0_v1 = new C0_B0(1); +>C0_B0_v1 : Symbol(C0_B0_v1, Decl(main.js, 33, 5)) +>C0_B0 : Symbol(C0_B0, Decl(main.js, 16, 24)) + +const C0_B0_v1_y = C0_B0_v1.y; +>C0_B0_v1_y : Symbol(C0_B0_v1_y, Decl(main.js, 34, 5)) +>C0_B0_v1.y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) +>C0_B0_v1 : Symbol(C0_B0_v1, Decl(main.js, 33, 5)) +>y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) + +const C0_B1_v0 = new C0_B1(); +>C0_B1_v0 : Symbol(C0_B1_v0, Decl(main.js, 36, 5)) +>C0_B1 : Symbol(C0_B1, Decl(main.js, 18, 25)) + +const C0_B1_v0_y = C0_B1_v0.y; +>C0_B1_v0_y : Symbol(C0_B1_v0_y, Decl(main.js, 37, 5)) +>C0_B1_v0.y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) +>C0_B1_v0 : Symbol(C0_B1_v0, Decl(main.js, 36, 5)) +>y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) + +const C0_B2_v0 = new C0_B2(); +>C0_B2_v0 : Symbol(C0_B2_v0, Decl(main.js, 39, 5)) +>C0_B2 : Symbol(C0_B2, Decl(main.js, 23, 1)) + +const C0_B2_v0_y = C0_B2_v0.y; +>C0_B2_v0_y : Symbol(C0_B2_v0_y, Decl(main.js, 40, 5)) +>C0_B2_v0.y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) +>C0_B2_v0 : Symbol(C0_B2_v0, Decl(main.js, 39, 5)) +>y : Symbol(C0.y, Decl(decls.d.ts, 2, 21)) + +class C1_B0 extends C1 {} +>C1_B0 : Symbol(C1_B0, Decl(main.js, 40, 30)) +>C1 : Symbol(C1, Decl(decls.d.ts, 5, 1)) + +class C1_B1 extends C1 { +>C1_B1 : Symbol(C1_B1, Decl(main.js, 42, 25)) +>C1 : Symbol(C1, Decl(decls.d.ts, 5, 1)) + + constructor() { + super(); +>super : Symbol(C1, Decl(decls.d.ts, 5, 1)) + } +} +class C1_B2 extends C1 { +>C1_B2 : Symbol(C1_B2, Decl(main.js, 47, 1)) +>C1 : Symbol(C1, Decl(decls.d.ts, 5, 1)) + + constructor() { + super(1); +>super : Symbol(C1, Decl(decls.d.ts, 5, 1)) + } +} + +const C1_B0_v0 = new C1_B0(); +>C1_B0_v0 : Symbol(C1_B0_v0, Decl(main.js, 54, 5)) +>C1_B0 : Symbol(C1_B0, Decl(main.js, 40, 30)) + +const C1_B0_v0_y = C1_B0_v0.y; +>C1_B0_v0_y : Symbol(C1_B0_v0_y, Decl(main.js, 55, 5)) +>C1_B0_v0.y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) +>C1_B0_v0 : Symbol(C1_B0_v0, Decl(main.js, 54, 5)) +>y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) + +const C1_B0_v1 = new C1_B0(1); +>C1_B0_v1 : Symbol(C1_B0_v1, Decl(main.js, 57, 5)) +>C1_B0 : Symbol(C1_B0, Decl(main.js, 40, 30)) + +const C1_B0_v1_y = C1_B0_v1.y; +>C1_B0_v1_y : Symbol(C1_B0_v1_y, Decl(main.js, 58, 5)) +>C1_B0_v1.y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) +>C1_B0_v1 : Symbol(C1_B0_v1, Decl(main.js, 57, 5)) +>y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) + +const C1_B1_v0 = new C1_B1(); +>C1_B1_v0 : Symbol(C1_B1_v0, Decl(main.js, 60, 5)) +>C1_B1 : Symbol(C1_B1, Decl(main.js, 42, 25)) + +const C1_B1_v0_y = C1_B1_v0.y; +>C1_B1_v0_y : Symbol(C1_B1_v0_y, Decl(main.js, 61, 5)) +>C1_B1_v0.y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) +>C1_B1_v0 : Symbol(C1_B1_v0, Decl(main.js, 60, 5)) +>y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) + +const C1_B2_v0 = new C1_B2(); +>C1_B2_v0 : Symbol(C1_B2_v0, Decl(main.js, 63, 5)) +>C1_B2 : Symbol(C1_B2, Decl(main.js, 47, 1)) + +const C1_B2_v0_y = C1_B2_v0.y; +>C1_B2_v0_y : Symbol(C1_B2_v0_y, Decl(main.js, 64, 5)) +>C1_B2_v0.y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) +>C1_B2_v0 : Symbol(C1_B2_v0, Decl(main.js, 63, 5)) +>y : Symbol(C1.y, Decl(decls.d.ts, 6, 33)) + diff --git a/tests/baselines/reference/genericDefaultsJs.types b/tests/baselines/reference/genericDefaultsJs.types new file mode 100644 index 0000000000000..3275e757d7902 --- /dev/null +++ b/tests/baselines/reference/genericDefaultsJs.types @@ -0,0 +1,254 @@ +=== tests/cases/compiler/decls.d.ts === +declare function f0(x?: T): T; +>f0 : (x?: T) => T +>T : T +>x : T +>T : T +>T : T + +declare function f1(x?: T): [T, U]; +>f1 : (x?: T) => [T, U] +>T : T +>U : U +>x : T +>T : T +>T : T +>U : U + +declare class C0 { +>C0 : C0 +>T : T + + y: T; +>y : T +>T : T + + constructor(x?: T); +>x : T +>T : T +} +declare class C1 { +>C1 : C1 +>T : T +>U : U + + y: [T, U]; +>y : [T, U] +>T : T +>U : U + + constructor(x?: T); +>x : T +>T : T +} +=== tests/cases/compiler/main.js === +const f0_v0 = f0(); +>f0_v0 : any +>f0() : any +>f0 : (x?: T) => T + +const f0_v1 = f0(1); +>f0_v1 : 1 +>f0(1) : 1 +>f0 : (x?: T) => T +>1 : 1 + +const f1_c0 = f1(); +>f1_c0 : [any, number] +>f1() : [any, number] +>f1 : (x?: T) => [T, U] + +const f1_c1 = f1(1); +>f1_c1 : [number, number] +>f1(1) : [number, number] +>f1 : (x?: T) => [T, U] +>1 : 1 + +const C0_v0 = new C0(); +>C0_v0 : C0 +>new C0() : C0 +>C0 : typeof C0 + +const C0_v0_y = C0_v0.y; +>C0_v0_y : any +>C0_v0.y : any +>C0_v0 : C0 +>y : any + +const C0_v1 = new C0(1); +>C0_v1 : C0 +>new C0(1) : C0 +>C0 : typeof C0 +>1 : 1 + +const C0_v1_y = C0_v1.y; +>C0_v1_y : number +>C0_v1.y : number +>C0_v1 : C0 +>y : number + +const C1_v0 = new C1(); +>C1_v0 : C1 +>new C1() : C1 +>C1 : typeof C1 + +const C1_v0_y = C1_v0.y; +>C1_v0_y : [any, number] +>C1_v0.y : [any, number] +>C1_v0 : C1 +>y : [any, number] + +const C1_v1 = new C1(1); +>C1_v1 : C1 +>new C1(1) : C1 +>C1 : typeof C1 +>1 : 1 + +const C1_v1_y = C1_v1.y; +>C1_v1_y : [number, number] +>C1_v1.y : [number, number] +>C1_v1 : C1 +>y : [number, number] + +class C0_B0 extends C0 {} +>C0_B0 : C0_B0 +>C0 : C0 + +class C0_B1 extends C0 { +>C0_B1 : C0_B1 +>C0 : C0 + + constructor() { + super(); +>super() : void +>super : typeof C0 + } +} +class C0_B2 extends C0 { +>C0_B2 : C0_B2 +>C0 : C0 + + constructor() { + super(1); +>super(1) : void +>super : typeof C0 +>1 : 1 + } +} + +const C0_B0_v0 = new C0_B0(); +>C0_B0_v0 : C0_B0 +>new C0_B0() : C0_B0 +>C0_B0 : typeof C0_B0 + +const C0_B0_v0_y = C0_B0_v0.y; +>C0_B0_v0_y : any +>C0_B0_v0.y : any +>C0_B0_v0 : C0_B0 +>y : any + +const C0_B0_v1 = new C0_B0(1); +>C0_B0_v1 : C0_B0 +>new C0_B0(1) : C0_B0 +>C0_B0 : typeof C0_B0 +>1 : 1 + +const C0_B0_v1_y = C0_B0_v1.y; +>C0_B0_v1_y : any +>C0_B0_v1.y : any +>C0_B0_v1 : C0_B0 +>y : any + +const C0_B1_v0 = new C0_B1(); +>C0_B1_v0 : C0_B1 +>new C0_B1() : C0_B1 +>C0_B1 : typeof C0_B1 + +const C0_B1_v0_y = C0_B1_v0.y; +>C0_B1_v0_y : any +>C0_B1_v0.y : any +>C0_B1_v0 : C0_B1 +>y : any + +const C0_B2_v0 = new C0_B2(); +>C0_B2_v0 : C0_B2 +>new C0_B2() : C0_B2 +>C0_B2 : typeof C0_B2 + +const C0_B2_v0_y = C0_B2_v0.y; +>C0_B2_v0_y : any +>C0_B2_v0.y : any +>C0_B2_v0 : C0_B2 +>y : any + +class C1_B0 extends C1 {} +>C1_B0 : C1_B0 +>C1 : C1 + +class C1_B1 extends C1 { +>C1_B1 : C1_B1 +>C1 : C1 + + constructor() { + super(); +>super() : void +>super : typeof C1 + } +} +class C1_B2 extends C1 { +>C1_B2 : C1_B2 +>C1 : C1 + + constructor() { + super(1); +>super(1) : void +>super : typeof C1 +>1 : 1 + } +} + +const C1_B0_v0 = new C1_B0(); +>C1_B0_v0 : C1_B0 +>new C1_B0() : C1_B0 +>C1_B0 : typeof C1_B0 + +const C1_B0_v0_y = C1_B0_v0.y; +>C1_B0_v0_y : [any, number] +>C1_B0_v0.y : [any, number] +>C1_B0_v0 : C1_B0 +>y : [any, number] + +const C1_B0_v1 = new C1_B0(1); +>C1_B0_v1 : C1_B0 +>new C1_B0(1) : C1_B0 +>C1_B0 : typeof C1_B0 +>1 : 1 + +const C1_B0_v1_y = C1_B0_v1.y; +>C1_B0_v1_y : [any, number] +>C1_B0_v1.y : [any, number] +>C1_B0_v1 : C1_B0 +>y : [any, number] + +const C1_B1_v0 = new C1_B1(); +>C1_B1_v0 : C1_B1 +>new C1_B1() : C1_B1 +>C1_B1 : typeof C1_B1 + +const C1_B1_v0_y = C1_B1_v0.y; +>C1_B1_v0_y : [any, number] +>C1_B1_v0.y : [any, number] +>C1_B1_v0 : C1_B1 +>y : [any, number] + +const C1_B2_v0 = new C1_B2(); +>C1_B2_v0 : C1_B2 +>new C1_B2() : C1_B2 +>C1_B2 : typeof C1_B2 + +const C1_B2_v0_y = C1_B2_v0.y; +>C1_B2_v0_y : [any, number] +>C1_B2_v0.y : [any, number] +>C1_B2_v0 : C1_B2 +>y : [any, number] + diff --git a/tests/baselines/reference/giant.errors.txt b/tests/baselines/reference/giant.errors.txt index 2c7e6f505bd69..809ae03635824 100644 --- a/tests/baselines/reference/giant.errors.txt +++ b/tests/baselines/reference/giant.errors.txt @@ -1,272 +1,271 @@ -tests/cases/compiler/giant.ts(23,12): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(24,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(24,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(25,12): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(26,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(26,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(27,13): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(28,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(28,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(29,13): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(30,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(30,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(33,12): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(34,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(34,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(35,12): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(36,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(36,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(61,5): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(61,6): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(62,5): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(63,6): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(76,5): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(87,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(88,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(88,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(89,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(90,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(90,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(91,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(92,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(92,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(93,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(94,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(94,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(97,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(98,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(98,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(99,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(100,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(100,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(125,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(125,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(126,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(127,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(140,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(154,39): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(166,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(167,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(167,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(168,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(169,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(169,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(170,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(171,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(171,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(172,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(173,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(173,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(176,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(177,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(177,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(178,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(179,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(179,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(204,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(204,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(205,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(206,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(219,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(233,39): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(238,35): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(240,24): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(243,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(22,12): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(23,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(23,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(24,12): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(25,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(25,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(26,13): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(27,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(27,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(28,13): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(29,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(29,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(32,12): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(33,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(33,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(34,12): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(35,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(35,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(60,5): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(60,6): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(61,5): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(62,6): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(75,5): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(86,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(87,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(87,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(88,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(89,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(89,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(90,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(91,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(91,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(92,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(93,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(93,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(96,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(97,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(97,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(98,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(99,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(99,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(124,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(124,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(125,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(126,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(139,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(153,39): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(165,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(166,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(166,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(167,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(168,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(168,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(169,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(170,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(170,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(171,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(172,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(172,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(175,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(176,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(176,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(177,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(178,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(178,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(203,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(203,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(204,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(205,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(218,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(232,39): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(237,35): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(239,24): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(242,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(243,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(244,16): error TS2300: Duplicate identifier 'pgF'. tests/cases/compiler/giant.ts(244,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(245,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(245,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(246,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(246,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(247,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(247,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(248,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(248,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(249,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(249,23): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(250,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(250,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(251,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(251,32): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(252,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(252,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(254,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(255,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(255,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(256,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(256,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(257,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(257,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(258,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(258,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(262,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(262,25): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(267,30): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(281,12): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(282,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(282,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(283,12): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(284,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(284,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(285,13): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(286,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(286,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(287,13): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(288,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(288,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(291,12): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(292,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(292,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(293,12): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(294,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(294,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(319,5): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(319,6): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(320,5): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(321,6): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(334,5): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(345,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(346,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(346,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(347,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(348,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(348,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(349,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(350,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(350,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(351,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(352,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(352,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(355,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(356,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(356,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(357,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(358,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(358,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(383,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(383,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(384,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(385,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(398,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(412,39): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(424,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(425,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(425,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(426,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(427,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(427,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(428,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(429,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(429,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(430,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(431,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(431,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(434,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(435,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(435,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(436,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(437,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(437,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(462,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(462,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(463,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(464,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(477,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(491,39): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(496,35): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(498,24): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(501,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(245,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(245,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(246,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(246,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(247,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(247,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(248,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(248,23): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(249,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(249,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(250,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(250,32): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(251,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(251,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(253,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(254,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(254,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(255,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(255,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(256,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(256,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(257,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(257,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(261,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(261,25): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(266,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(280,12): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(281,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(281,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(282,12): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(283,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(283,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(284,13): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(285,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(285,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(286,13): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(287,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(287,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(290,12): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(291,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(291,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(292,12): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(293,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(293,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(318,5): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(318,6): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(319,5): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(320,6): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(333,5): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(344,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(345,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(345,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(346,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(347,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(347,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(348,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(349,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(349,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(350,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(351,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(351,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(354,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(355,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(355,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(356,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(357,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(357,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(382,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(382,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(383,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(384,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(397,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(411,39): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(423,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(424,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(424,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(425,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(426,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(426,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(427,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(428,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(428,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(429,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(430,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(430,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(433,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(434,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(434,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(435,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(436,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(436,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(461,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(461,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(462,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(463,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(476,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(490,39): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(495,35): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(497,24): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(500,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(501,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(502,16): error TS2300: Duplicate identifier 'pgF'. tests/cases/compiler/giant.ts(502,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(503,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(503,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(504,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(504,20): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(505,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(505,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(506,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(506,20): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(507,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(507,23): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(508,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(508,21): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(509,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(509,32): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(510,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(510,21): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(512,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(513,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(513,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(514,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(514,20): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(515,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(515,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(516,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(516,20): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(520,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(520,25): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(525,30): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(532,31): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(534,20): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(537,17): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(503,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(503,20): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(504,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(504,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(505,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(505,20): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(506,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(506,23): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(507,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(507,21): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(508,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(508,32): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(509,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(509,21): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(511,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(512,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(512,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(513,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(513,20): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(514,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(514,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(515,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(515,20): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(519,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(519,25): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(524,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(531,31): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(533,20): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(536,17): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(537,18): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(538,12): error TS2300: Duplicate identifier 'pgF'. tests/cases/compiler/giant.ts(538,18): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(539,12): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(539,18): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(540,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(540,16): error TS2300: Duplicate identifier 'pgF'. -tests/cases/compiler/giant.ts(541,12): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(541,27): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(542,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(542,16): error TS2300: Duplicate identifier 'psF'. -tests/cases/compiler/giant.ts(543,13): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(543,19): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(544,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(544,17): error TS2300: Duplicate identifier 'rgF'. -tests/cases/compiler/giant.ts(545,13): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(545,28): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(546,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(546,17): error TS2300: Duplicate identifier 'rsF'. -tests/cases/compiler/giant.ts(548,17): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(549,12): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(549,27): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(550,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(550,16): error TS2300: Duplicate identifier 'tsF'. -tests/cases/compiler/giant.ts(551,12): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(551,18): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(552,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/giant.ts(552,16): error TS2300: Duplicate identifier 'tgF'. -tests/cases/compiler/giant.ts(556,18): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(556,21): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(558,24): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(561,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(563,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(587,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(587,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(588,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(589,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(602,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(606,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(606,25): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(611,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(539,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(539,16): error TS2300: Duplicate identifier 'pgF'. +tests/cases/compiler/giant.ts(540,12): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(540,27): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(541,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(541,16): error TS2300: Duplicate identifier 'psF'. +tests/cases/compiler/giant.ts(542,13): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(542,19): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(543,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(543,17): error TS2300: Duplicate identifier 'rgF'. +tests/cases/compiler/giant.ts(544,13): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(544,28): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(545,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(545,17): error TS2300: Duplicate identifier 'rsF'. +tests/cases/compiler/giant.ts(547,17): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(548,12): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(548,27): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(549,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(549,16): error TS2300: Duplicate identifier 'tsF'. +tests/cases/compiler/giant.ts(550,12): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(550,18): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(551,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/giant.ts(551,16): error TS2300: Duplicate identifier 'tgF'. +tests/cases/compiler/giant.ts(555,18): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(555,21): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(557,24): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(560,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(562,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(586,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(586,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(587,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(588,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(601,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(605,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(605,25): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(610,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(614,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. tests/cases/compiler/giant.ts(615,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. +tests/cases/compiler/giant.ts(615,39): error TS1183: An implementation cannot be declared in ambient contexts. tests/cases/compiler/giant.ts(616,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/giant.ts(616,39): error TS1183: An implementation cannot be declared in ambient contexts. tests/cases/compiler/giant.ts(617,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/giant.ts(618,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/giant.ts(621,26): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(623,24): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(626,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(628,21): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(653,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. -tests/cases/compiler/giant.ts(653,10): error TS2304: Cannot find name 'p'. -tests/cases/compiler/giant.ts(654,9): error TS1021: An index signature must have a type annotation. -tests/cases/compiler/giant.ts(655,10): error TS1096: An index signature must have exactly one parameter. -tests/cases/compiler/giant.ts(668,9): error TS2386: Overload signatures must all be optional or required. -tests/cases/compiler/giant.ts(672,22): error TS1183: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(672,25): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/compiler/giant.ts(676,30): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(620,26): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(622,24): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(625,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(627,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(652,9): error TS1169: A computed property name in an interface must directly refer to a built-in symbol. +tests/cases/compiler/giant.ts(652,10): error TS2304: Cannot find name 'p'. +tests/cases/compiler/giant.ts(653,9): error TS1021: An index signature must have a type annotation. +tests/cases/compiler/giant.ts(654,10): error TS1096: An index signature must have exactly one parameter. +tests/cases/compiler/giant.ts(667,9): error TS2386: Overload signatures must all be optional or required. +tests/cases/compiler/giant.ts(671,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/giant.ts(671,25): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/compiler/giant.ts(675,30): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/compiler/giant.ts (265 errors) ==== - /* Prefixes p -> public diff --git a/tests/baselines/reference/giant.js b/tests/baselines/reference/giant.js index ce4df039932fc..71f78eeac53d8 100644 --- a/tests/baselines/reference/giant.js +++ b/tests/baselines/reference/giant.js @@ -1,5 +1,4 @@ //// [giant.ts] - /* Prefixes p -> public diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.js b/tests/baselines/reference/globalAugmentationModuleResolution.js index 6dd87de81fd3f..fae150bb709be 100644 --- a/tests/baselines/reference/globalAugmentationModuleResolution.js +++ b/tests/baselines/reference/globalAugmentationModuleResolution.js @@ -1,5 +1,4 @@ //// [a.ts] - export { }; declare global { diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.symbols b/tests/baselines/reference/globalAugmentationModuleResolution.symbols index 614860d654e97..567c7e2b4f088 100644 --- a/tests/baselines/reference/globalAugmentationModuleResolution.symbols +++ b/tests/baselines/reference/globalAugmentationModuleResolution.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/externalModules/a.ts === - export { }; declare global { ->global : Symbol(global, Decl(a.ts, 1, 11)) +>global : Symbol(global, Decl(a.ts, 0, 11)) var x: number; ->x : Symbol(x, Decl(a.ts, 4, 5)) +>x : Symbol(x, Decl(a.ts, 3, 5)) } diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.types b/tests/baselines/reference/globalAugmentationModuleResolution.types index 75f23b0cd6b81..8d9bf23bcc23c 100644 --- a/tests/baselines/reference/globalAugmentationModuleResolution.types +++ b/tests/baselines/reference/globalAugmentationModuleResolution.types @@ -1,5 +1,4 @@ === tests/cases/conformance/externalModules/a.ts === - export { }; declare global { diff --git a/tests/baselines/reference/ifDoWhileStatements.js b/tests/baselines/reference/ifDoWhileStatements.js index 22dd78a968733..711ce1315dc80 100644 --- a/tests/baselines/reference/ifDoWhileStatements.js +++ b/tests/baselines/reference/ifDoWhileStatements.js @@ -1,5 +1,4 @@ //// [ifDoWhileStatements.ts] - interface I { id: number; } diff --git a/tests/baselines/reference/ifDoWhileStatements.symbols b/tests/baselines/reference/ifDoWhileStatements.symbols index b0ec471aa4876..32a5437aac7a4 100644 --- a/tests/baselines/reference/ifDoWhileStatements.symbols +++ b/tests/baselines/reference/ifDoWhileStatements.symbols @@ -1,93 +1,92 @@ === tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts === - interface I { >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0)) id: number; ->id : Symbol(I.id, Decl(ifDoWhileStatements.ts, 1, 13)) +>id : Symbol(I.id, Decl(ifDoWhileStatements.ts, 0, 13)) } class C implements I { ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0)) id: number; ->id : Symbol(C.id, Decl(ifDoWhileStatements.ts, 5, 22)) +>id : Symbol(C.id, Decl(ifDoWhileStatements.ts, 4, 22)) name: string; ->name : Symbol(C.name, Decl(ifDoWhileStatements.ts, 6, 15)) +>name : Symbol(C.name, Decl(ifDoWhileStatements.ts, 5, 15)) } class C2 extends C { ->C2 : Symbol(C2, Decl(ifDoWhileStatements.ts, 8, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C2 : Symbol(C2, Decl(ifDoWhileStatements.ts, 7, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) valid: boolean; ->valid : Symbol(C2.valid, Decl(ifDoWhileStatements.ts, 10, 20)) +>valid : Symbol(C2.valid, Decl(ifDoWhileStatements.ts, 9, 20)) } class D{ ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) source: T; ->source : Symbol(D.source, Decl(ifDoWhileStatements.ts, 14, 11)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) +>source : Symbol(D.source, Decl(ifDoWhileStatements.ts, 13, 11)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) recurse: D; ->recurse : Symbol(D.recurse, Decl(ifDoWhileStatements.ts, 15, 14)) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) +>recurse : Symbol(D.recurse, Decl(ifDoWhileStatements.ts, 14, 14)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) wrapped: D> ->wrapped : Symbol(D.wrapped, Decl(ifDoWhileStatements.ts, 16, 18)) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) +>wrapped : Symbol(D.wrapped, Decl(ifDoWhileStatements.ts, 15, 18)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) } function F(x: string): number { return 42; } ->F : Symbol(F, Decl(ifDoWhileStatements.ts, 18, 1)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 11)) +>F : Symbol(F, Decl(ifDoWhileStatements.ts, 17, 1)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 19, 11)) function F2(x: number): boolean { return x < 42; } ->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 20, 44)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12)) +>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 19, 44)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 12)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 12)) module M { ->M : Symbol(M, Decl(ifDoWhileStatements.ts, 21, 50)) +>M : Symbol(M, Decl(ifDoWhileStatements.ts, 20, 50)) export class A { ->A : Symbol(A, Decl(ifDoWhileStatements.ts, 23, 10)) +>A : Symbol(A, Decl(ifDoWhileStatements.ts, 22, 10)) name: string; ->name : Symbol(A.name, Decl(ifDoWhileStatements.ts, 24, 20)) +>name : Symbol(A.name, Decl(ifDoWhileStatements.ts, 23, 20)) } export function F2(x: number): string { return x.toString(); } ->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 26, 5)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23)) +>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 25, 5)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } module N { ->N : Symbol(N, Decl(ifDoWhileStatements.ts, 29, 1)) +>N : Symbol(N, Decl(ifDoWhileStatements.ts, 28, 1)) export class A { ->A : Symbol(A, Decl(ifDoWhileStatements.ts, 31, 10)) +>A : Symbol(A, Decl(ifDoWhileStatements.ts, 30, 10)) id: number; ->id : Symbol(A.id, Decl(ifDoWhileStatements.ts, 32, 20)) +>id : Symbol(A.id, Decl(ifDoWhileStatements.ts, 31, 20)) } export function F2(x: number): string { return x.toString(); } ->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 34, 5)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23)) +>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 33, 5)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } @@ -138,200 +137,200 @@ while ({}) { } do { }while({}) if ({ x: 1, y: 'a' }) { } ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 5)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 11)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 79, 5)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 79, 11)) while ({ x: 1, y: 'a' }) { } ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 8)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 14)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 8)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 14)) do { }while({ x: 1, y: 'a' }) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 82, 13)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 82, 19)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 13)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 19)) if (() => 43) { } while (() => 43) { } do { }while(() => 43) if (new C()) { } ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) while (new C()) { } ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) do { }while(new C()) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) if (new D()) { } ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) while (new D()) { } ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) do { }while(new D()) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) // references var a = true; ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) if (a) { } ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) while (a) { } ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) do { }while(a) ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) var b = null; ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) if (b) { } ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) while (b) { } ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) do { }while(b) ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) var c = undefined; ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) >undefined : Symbol(undefined) if (c) { } ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) while (c) { } ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) do { }while(c) ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) var d = 0.0; ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) if (d) { } ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) while (d) { } ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) do { }while(d) ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) var e = 'a string'; ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) if (e) { } ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) while (e) { } ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) do { }while(e) ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) var f = ''; ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) if (f) { } ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) while (f) { } ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) do { }while(f) ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) var g = /[a-z]/ ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) if (g) { } ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) while (g) { } ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) do { }while(g) ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) var h = []; ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) if (h) { } ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) while (h) { } ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) do { }while(h) ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) var i = [1, 2]; ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) if (i) { } ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) while (i) { } ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) do { }while(i) ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) var j = {}; ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) if (j) { } ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) while (j) { } ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) do { }while(j) ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) var k = { x: 1, y: 'a' }; ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 147, 9)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 147, 15)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 146, 9)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 146, 15)) if (k) { } ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) while (k) { } ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) do { }while(k) ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) function fn(x?: string): I { return null; } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 152, 12)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 151, 12)) >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0)) if (fn()) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) while (fn()) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) do { }while(fn()) ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) if (fn) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) while (fn) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) do { }while(fn) ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) diff --git a/tests/baselines/reference/ifDoWhileStatements.types b/tests/baselines/reference/ifDoWhileStatements.types index eee459391c508..801b4d35f2f7f 100644 --- a/tests/baselines/reference/ifDoWhileStatements.types +++ b/tests/baselines/reference/ifDoWhileStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts === - interface I { >I : I diff --git a/tests/baselines/reference/ifElseWithStatements1.errors.txt b/tests/baselines/reference/ifElseWithStatements1.errors.txt index 5dc4d9b0db585..186cff5924139 100644 --- a/tests/baselines/reference/ifElseWithStatements1.errors.txt +++ b/tests/baselines/reference/ifElseWithStatements1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/ifElseWithStatements1.ts(3,5): error TS2304: Cannot find name 'f'. -tests/cases/compiler/ifElseWithStatements1.ts(5,5): error TS2304: Cannot find name 'f'. +tests/cases/compiler/ifElseWithStatements1.ts(2,5): error TS2304: Cannot find name 'f'. +tests/cases/compiler/ifElseWithStatements1.ts(4,5): error TS2304: Cannot find name 'f'. ==== tests/cases/compiler/ifElseWithStatements1.ts (2 errors) ==== - if (true) f(); ~ diff --git a/tests/baselines/reference/ifElseWithStatements1.js b/tests/baselines/reference/ifElseWithStatements1.js index 47df08d46baa5..506e7e6a33071 100644 --- a/tests/baselines/reference/ifElseWithStatements1.js +++ b/tests/baselines/reference/ifElseWithStatements1.js @@ -1,5 +1,4 @@ //// [ifElseWithStatements1.ts] - if (true) f(); else diff --git a/tests/baselines/reference/implicitAnyAmbients.errors.txt b/tests/baselines/reference/implicitAnyAmbients.errors.txt index d425edbfefd47..07c69b75a9b20 100644 --- a/tests/baselines/reference/implicitAnyAmbients.errors.txt +++ b/tests/baselines/reference/implicitAnyAmbients.errors.txt @@ -1,16 +1,15 @@ -tests/cases/compiler/implicitAnyAmbients.ts(3,9): error TS7005: Variable 'x' implicitly has an 'any' type. -tests/cases/compiler/implicitAnyAmbients.ts(6,14): error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(6,16): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/implicitAnyAmbients.ts(7,14): error TS7010: 'f2', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(11,9): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(12,9): error TS7010: 'foo2', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(17,9): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(18,9): error TS7010: 'foo2', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/implicitAnyAmbients.ts(23,13): error TS7005: Variable 'y' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyAmbients.ts(2,9): error TS7005: Variable 'x' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyAmbients.ts(5,14): error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(5,16): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyAmbients.ts(6,14): error TS7010: 'f2', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(10,9): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(11,9): error TS7010: 'foo2', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(16,9): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(17,9): error TS7010: 'foo2', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/implicitAnyAmbients.ts(22,13): error TS7005: Variable 'y' implicitly has an 'any' type. ==== tests/cases/compiler/implicitAnyAmbients.ts (9 errors) ==== - declare module m { var x; // error ~ diff --git a/tests/baselines/reference/implicitAnyAmbients.js b/tests/baselines/reference/implicitAnyAmbients.js index 6b63bf8b819be..fe832c279b6c1 100644 --- a/tests/baselines/reference/implicitAnyAmbients.js +++ b/tests/baselines/reference/implicitAnyAmbients.js @@ -1,5 +1,4 @@ //// [implicitAnyAmbients.ts] - declare module m { var x; // error var y: any; diff --git a/tests/baselines/reference/implicitAnyFromCircularInference.errors.txt b/tests/baselines/reference/implicitAnyFromCircularInference.errors.txt index 7d4dfa2cf5e39..441d27952aef8 100644 --- a/tests/baselines/reference/implicitAnyFromCircularInference.errors.txt +++ b/tests/baselines/reference/implicitAnyFromCircularInference.errors.txt @@ -1,17 +1,16 @@ -tests/cases/compiler/implicitAnyFromCircularInference.ts(3,5): error TS2502: 'a' is referenced directly or indirectly in its own type annotation. -tests/cases/compiler/implicitAnyFromCircularInference.ts(6,5): error TS2502: 'b' is referenced directly or indirectly in its own type annotation. -tests/cases/compiler/implicitAnyFromCircularInference.ts(7,5): error TS2502: 'c' is referenced directly or indirectly in its own type annotation. -tests/cases/compiler/implicitAnyFromCircularInference.ts(10,5): error TS2502: 'd' is referenced directly or indirectly in its own type annotation. -tests/cases/compiler/implicitAnyFromCircularInference.ts(15,10): error TS7023: 'g' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(18,10): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(23,10): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(26,10): error TS7023: 'h' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(28,14): error TS7023: 'foo' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/compiler/implicitAnyFromCircularInference.ts(46,9): error TS7023: 'x' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(2,5): error TS2502: 'a' is referenced directly or indirectly in its own type annotation. +tests/cases/compiler/implicitAnyFromCircularInference.ts(5,5): error TS2502: 'b' is referenced directly or indirectly in its own type annotation. +tests/cases/compiler/implicitAnyFromCircularInference.ts(6,5): error TS2502: 'c' is referenced directly or indirectly in its own type annotation. +tests/cases/compiler/implicitAnyFromCircularInference.ts(9,5): error TS2502: 'd' is referenced directly or indirectly in its own type annotation. +tests/cases/compiler/implicitAnyFromCircularInference.ts(14,10): error TS7023: 'g' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(17,10): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(22,10): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(25,10): error TS7023: 'h' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(27,14): error TS7023: 'foo' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/compiler/implicitAnyFromCircularInference.ts(45,9): error TS7023: 'x' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. ==== tests/cases/compiler/implicitAnyFromCircularInference.ts (10 errors) ==== - // Error expected var a: typeof a; ~ diff --git a/tests/baselines/reference/implicitAnyFromCircularInference.js b/tests/baselines/reference/implicitAnyFromCircularInference.js index 9fa4f3ff225f0..b55db223c7570 100644 --- a/tests/baselines/reference/implicitAnyFromCircularInference.js +++ b/tests/baselines/reference/implicitAnyFromCircularInference.js @@ -1,5 +1,4 @@ //// [implicitAnyFromCircularInference.ts] - // Error expected var a: typeof a; diff --git a/tests/baselines/reference/implicitAnyGenericTypeInference.errors.txt b/tests/baselines/reference/implicitAnyGenericTypeInference.errors.txt index c479d06d8986b..0c64c3e612535 100644 --- a/tests/baselines/reference/implicitAnyGenericTypeInference.errors.txt +++ b/tests/baselines/reference/implicitAnyGenericTypeInference.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/implicitAnyGenericTypeInference.ts(7,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/implicitAnyGenericTypeInference.ts(7,22): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyGenericTypeInference.ts(6,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/implicitAnyGenericTypeInference.ts(6,22): error TS7006: Parameter 'y' implicitly has an 'any' type. ==== tests/cases/compiler/implicitAnyGenericTypeInference.ts (2 errors) ==== - interface Comparer { compareTo(x: T, y: U): U; } diff --git a/tests/baselines/reference/implicitAnyGenericTypeInference.js b/tests/baselines/reference/implicitAnyGenericTypeInference.js index 583ab7f0b01a3..49c94b68f6038 100644 --- a/tests/baselines/reference/implicitAnyGenericTypeInference.js +++ b/tests/baselines/reference/implicitAnyGenericTypeInference.js @@ -1,5 +1,4 @@ //// [implicitAnyGenericTypeInference.ts] - interface Comparer { compareTo(x: T, y: U): U; } diff --git a/tests/baselines/reference/implicitAnyGenerics.js b/tests/baselines/reference/implicitAnyGenerics.js index 07478cf001114..172d6c4da3ada 100644 --- a/tests/baselines/reference/implicitAnyGenerics.js +++ b/tests/baselines/reference/implicitAnyGenerics.js @@ -1,5 +1,4 @@ //// [implicitAnyGenerics.ts] - class C { x: T; } diff --git a/tests/baselines/reference/implicitAnyGenerics.symbols b/tests/baselines/reference/implicitAnyGenerics.symbols index 22718f1b9d4d6..9e0ef397270be 100644 --- a/tests/baselines/reference/implicitAnyGenerics.symbols +++ b/tests/baselines/reference/implicitAnyGenerics.symbols @@ -1,71 +1,70 @@ === tests/cases/compiler/implicitAnyGenerics.ts === - class C { >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 1, 8)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 0, 8)) x: T; ->x : Symbol(C.x, Decl(implicitAnyGenerics.ts, 1, 12)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 1, 8)) +>x : Symbol(C.x, Decl(implicitAnyGenerics.ts, 0, 12)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 0, 8)) } var c = new C(); ->c : Symbol(c, Decl(implicitAnyGenerics.ts, 5, 3)) +>c : Symbol(c, Decl(implicitAnyGenerics.ts, 4, 3)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) var c2 = new C(); ->c2 : Symbol(c2, Decl(implicitAnyGenerics.ts, 6, 3)) +>c2 : Symbol(c2, Decl(implicitAnyGenerics.ts, 5, 3)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) var c3 = new C(); ->c3 : Symbol(c3, Decl(implicitAnyGenerics.ts, 7, 3)) +>c3 : Symbol(c3, Decl(implicitAnyGenerics.ts, 6, 3)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) var c4: C = new C(); ->c4 : Symbol(c4, Decl(implicitAnyGenerics.ts, 8, 3)) +>c4 : Symbol(c4, Decl(implicitAnyGenerics.ts, 7, 3)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) >C : Symbol(C, Decl(implicitAnyGenerics.ts, 0, 0)) class D { ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 10, 8)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 9, 8)) constructor(x: T) { } ->x : Symbol(x, Decl(implicitAnyGenerics.ts, 11, 16)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 10, 8)) +>x : Symbol(x, Decl(implicitAnyGenerics.ts, 10, 16)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 9, 8)) } var d = new D(null); ->d : Symbol(d, Decl(implicitAnyGenerics.ts, 14, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d : Symbol(d, Decl(implicitAnyGenerics.ts, 13, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) var d2 = new D(1); ->d2 : Symbol(d2, Decl(implicitAnyGenerics.ts, 15, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d2 : Symbol(d2, Decl(implicitAnyGenerics.ts, 14, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) var d3 = new D(1); ->d3 : Symbol(d3, Decl(implicitAnyGenerics.ts, 16, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d3 : Symbol(d3, Decl(implicitAnyGenerics.ts, 15, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) var d4 = new D(1); ->d4 : Symbol(d4, Decl(implicitAnyGenerics.ts, 17, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d4 : Symbol(d4, Decl(implicitAnyGenerics.ts, 16, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) var d5: D = new D(null); ->d5 : Symbol(d5, Decl(implicitAnyGenerics.ts, 18, 3)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) ->D : Symbol(D, Decl(implicitAnyGenerics.ts, 8, 25)) +>d5 : Symbol(d5, Decl(implicitAnyGenerics.ts, 17, 3)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) +>D : Symbol(D, Decl(implicitAnyGenerics.ts, 7, 25)) function foo(): T { return null; }; ->foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 18, 29)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 20, 13)) ->T : Symbol(T, Decl(implicitAnyGenerics.ts, 20, 13)) +>foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 17, 29)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 19, 13)) +>T : Symbol(T, Decl(implicitAnyGenerics.ts, 19, 13)) foo() ->foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 18, 29)) +>foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 17, 29)) foo(); ->foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 18, 29)) +>foo : Symbol(foo, Decl(implicitAnyGenerics.ts, 17, 29)) diff --git a/tests/baselines/reference/implicitAnyGenerics.types b/tests/baselines/reference/implicitAnyGenerics.types index 2d43ecbbdbec1..1202c73c51a86 100644 --- a/tests/baselines/reference/implicitAnyGenerics.types +++ b/tests/baselines/reference/implicitAnyGenerics.types @@ -1,5 +1,4 @@ === tests/cases/compiler/implicitAnyGenerics.ts === - class C { >C : C >T : T diff --git a/tests/baselines/reference/implicitConstParameters.errors.txt b/tests/baselines/reference/implicitConstParameters.errors.txt index 95ff60d71f809..101f1d35dd107 100644 --- a/tests/baselines/reference/implicitConstParameters.errors.txt +++ b/tests/baselines/reference/implicitConstParameters.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/implicitConstParameters.ts(39,27): error TS2532: Object is possibly 'undefined'. -tests/cases/compiler/implicitConstParameters.ts(45,27): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/implicitConstParameters.ts(38,27): error TS2532: Object is possibly 'undefined'. +tests/cases/compiler/implicitConstParameters.ts(44,27): error TS2532: Object is possibly 'undefined'. ==== tests/cases/compiler/implicitConstParameters.ts (2 errors) ==== - function doSomething(cb: () => void) { cb(); } diff --git a/tests/baselines/reference/implicitConstParameters.js b/tests/baselines/reference/implicitConstParameters.js index a5faf5b125354..29b23eda49329 100644 --- a/tests/baselines/reference/implicitConstParameters.js +++ b/tests/baselines/reference/implicitConstParameters.js @@ -1,5 +1,4 @@ //// [implicitConstParameters.ts] - function doSomething(cb: () => void) { cb(); } diff --git a/tests/baselines/reference/importHelpersInAmbientContext.js b/tests/baselines/reference/importHelpersInAmbientContext.js index d91daa19a907f..c1c0070595194 100644 --- a/tests/baselines/reference/importHelpersInAmbientContext.js +++ b/tests/baselines/reference/importHelpersInAmbientContext.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/importHelpersInAmbientContext.ts] //// //// [a.d.ts] - export { }; // Extends diff --git a/tests/baselines/reference/importHelpersInAmbientContext.symbols b/tests/baselines/reference/importHelpersInAmbientContext.symbols index 7da1ea950423c..172eea3037f41 100644 --- a/tests/baselines/reference/importHelpersInAmbientContext.symbols +++ b/tests/baselines/reference/importHelpersInAmbientContext.symbols @@ -1,28 +1,27 @@ === tests/cases/compiler/a.d.ts === - export { }; // Extends declare class C { } ->C : Symbol(C, Decl(a.d.ts, 1, 11)) +>C : Symbol(C, Decl(a.d.ts, 0, 11)) declare class D extends C { } ->D : Symbol(D, Decl(a.d.ts, 4, 19)) ->C : Symbol(C, Decl(a.d.ts, 1, 11)) +>D : Symbol(D, Decl(a.d.ts, 3, 19)) +>C : Symbol(C, Decl(a.d.ts, 0, 11)) // Destructuring interface I { ->I : Symbol(I, Decl(a.d.ts, 5, 29)) +>I : Symbol(I, Decl(a.d.ts, 4, 29)) ({descendants, read}?: { ->descendants : Symbol(descendants, Decl(a.d.ts, 9, 6)) ->read : Symbol(read, Decl(a.d.ts, 9, 18)) +>descendants : Symbol(descendants, Decl(a.d.ts, 8, 6)) +>read : Symbol(read, Decl(a.d.ts, 8, 18)) descendants?: boolean; ->descendants : Symbol(descendants, Decl(a.d.ts, 9, 28)) +>descendants : Symbol(descendants, Decl(a.d.ts, 8, 28)) read?: any; ->read : Symbol(read, Decl(a.d.ts, 10, 30)) +>read : Symbol(read, Decl(a.d.ts, 9, 30)) }): any; } @@ -30,16 +29,16 @@ interface I { // Object Rest interface Foo { ->Foo : Symbol(Foo, Decl(a.d.ts, 13, 1)) +>Foo : Symbol(Foo, Decl(a.d.ts, 12, 1)) a: number; b: string; ->a : Symbol(Foo.a, Decl(a.d.ts, 17, 15)) ->b : Symbol(Foo.b, Decl(a.d.ts, 18, 14)) +>a : Symbol(Foo.a, Decl(a.d.ts, 16, 15)) +>b : Symbol(Foo.b, Decl(a.d.ts, 17, 14)) } export var { a, ...x } : Foo; ->a : Symbol(a, Decl(a.d.ts, 20, 12)) ->x : Symbol(x, Decl(a.d.ts, 20, 15)) ->Foo : Symbol(Foo, Decl(a.d.ts, 13, 1)) +>a : Symbol(a, Decl(a.d.ts, 19, 12)) +>x : Symbol(x, Decl(a.d.ts, 19, 15)) +>Foo : Symbol(Foo, Decl(a.d.ts, 12, 1)) === tests/cases/compiler/b.ts === export {}; diff --git a/tests/baselines/reference/importHelpersInAmbientContext.types b/tests/baselines/reference/importHelpersInAmbientContext.types index 5f3102b68f5f1..5f01f5b161746 100644 --- a/tests/baselines/reference/importHelpersInAmbientContext.types +++ b/tests/baselines/reference/importHelpersInAmbientContext.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.d.ts === - export { }; // Extends diff --git a/tests/baselines/reference/importShadowsGlobalName.js b/tests/baselines/reference/importShadowsGlobalName.js index 94be0dfd5a0e4..64631ce54278e 100644 --- a/tests/baselines/reference/importShadowsGlobalName.js +++ b/tests/baselines/reference/importShadowsGlobalName.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/importShadowsGlobalName.ts] //// //// [Foo.ts] - class Foo {} export = Foo; diff --git a/tests/baselines/reference/importShadowsGlobalName.symbols b/tests/baselines/reference/importShadowsGlobalName.symbols index f308572737b75..8f99aa25adf2f 100644 --- a/tests/baselines/reference/importShadowsGlobalName.symbols +++ b/tests/baselines/reference/importShadowsGlobalName.symbols @@ -10,7 +10,6 @@ export = Bar; >Bar : Symbol(Bar, Decl(Bar.ts, 0, 30)) === tests/cases/compiler/Foo.ts === - class Foo {} >Foo : Symbol(Foo, Decl(Foo.ts, 0, 0)) diff --git a/tests/baselines/reference/importShadowsGlobalName.types b/tests/baselines/reference/importShadowsGlobalName.types index a1f1106f1b828..9c8e8c996946d 100644 --- a/tests/baselines/reference/importShadowsGlobalName.types +++ b/tests/baselines/reference/importShadowsGlobalName.types @@ -10,7 +10,6 @@ export = Bar; >Bar : Bar === tests/cases/compiler/Foo.ts === - class Foo {} >Foo : Foo diff --git a/tests/baselines/reference/importWithTrailingSlash.js b/tests/baselines/reference/importWithTrailingSlash.js index 9450fc5d7b2d8..9df01dcee66fd 100644 --- a/tests/baselines/reference/importWithTrailingSlash.js +++ b/tests/baselines/reference/importWithTrailingSlash.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/importWithTrailingSlash.ts] //// //// [a.ts] - export default { a: 0 }; //// [index.ts] diff --git a/tests/baselines/reference/importWithTrailingSlash.symbols b/tests/baselines/reference/importWithTrailingSlash.symbols index 4a9f8b415698f..c6c4946438010 100644 --- a/tests/baselines/reference/importWithTrailingSlash.symbols +++ b/tests/baselines/reference/importWithTrailingSlash.symbols @@ -1,7 +1,6 @@ === /a.ts === - export default { a: 0 }; ->a : Symbol(a, Decl(a.ts, 1, 16)) +>a : Symbol(a, Decl(a.ts, 0, 16)) === /a/index.ts === export default { aIndex: 0 }; @@ -15,9 +14,9 @@ import aIndex from "./"; >aIndex : Symbol(aIndex, Decl(test.ts, 1, 6)) a.a; ->a.a : Symbol(a, Decl(a.ts, 1, 16)) +>a.a : Symbol(a, Decl(a.ts, 0, 16)) >a : Symbol(a, Decl(test.ts, 0, 6)) ->a : Symbol(a, Decl(a.ts, 1, 16)) +>a : Symbol(a, Decl(a.ts, 0, 16)) aIndex.aIndex; >aIndex.aIndex : Symbol(aIndex, Decl(index.ts, 0, 16)) @@ -32,9 +31,9 @@ import aIndex from "../"; >aIndex : Symbol(aIndex, Decl(test.ts, 1, 6)) a.a; ->a.a : Symbol(a, Decl(a.ts, 1, 16)) +>a.a : Symbol(a, Decl(a.ts, 0, 16)) >a : Symbol(a, Decl(test.ts, 0, 6)) ->a : Symbol(a, Decl(a.ts, 1, 16)) +>a : Symbol(a, Decl(a.ts, 0, 16)) aIndex.aIndex; >aIndex.aIndex : Symbol(aIndex, Decl(index.ts, 0, 16)) diff --git a/tests/baselines/reference/importWithTrailingSlash.types b/tests/baselines/reference/importWithTrailingSlash.types index 7429dcdf42e82..beec18ea4aad9 100644 --- a/tests/baselines/reference/importWithTrailingSlash.types +++ b/tests/baselines/reference/importWithTrailingSlash.types @@ -1,5 +1,4 @@ === /a.ts === - export default { a: 0 }; >{ a: 0 } : { a: number; } >a : number diff --git a/tests/baselines/reference/importWithTrailingSlash_noResolve.errors.txt b/tests/baselines/reference/importWithTrailingSlash_noResolve.errors.txt index 780e1d2f1bc9c..e501cc5d432fc 100644 --- a/tests/baselines/reference/importWithTrailingSlash_noResolve.errors.txt +++ b/tests/baselines/reference/importWithTrailingSlash_noResolve.errors.txt @@ -1,8 +1,7 @@ -/a.ts(2,17): error TS2307: Cannot find module './foo/'. +/a.ts(1,17): error TS2307: Cannot find module './foo/'. ==== /a.ts (1 errors) ==== - import foo from "./foo/"; ~~~~~~~~ !!! error TS2307: Cannot find module './foo/'. diff --git a/tests/baselines/reference/importWithTrailingSlash_noResolve.js b/tests/baselines/reference/importWithTrailingSlash_noResolve.js index 16a4838ba6287..20afebedc2b1b 100644 --- a/tests/baselines/reference/importWithTrailingSlash_noResolve.js +++ b/tests/baselines/reference/importWithTrailingSlash_noResolve.js @@ -1,5 +1,4 @@ //// [a.ts] - import foo from "./foo/"; diff --git a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.js b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.js index 9b5e518804cc1..9e99e9c75ebf0 100644 --- a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.js +++ b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.js @@ -4,7 +4,6 @@ export class Host { } //// [consumer.ts] - import host = require("host"); var hostVar = host; var v = new hostVar.Host(); diff --git a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.symbols b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.symbols index 0cc6d0aa9a15b..7cd5c3fb3b57d 100644 --- a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.symbols +++ b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/consumer.ts === - import host = require("host"); >host : Symbol(host, Decl(consumer.ts, 0, 0)) var hostVar = host; ->hostVar : Symbol(hostVar, Decl(consumer.ts, 2, 3)) +>hostVar : Symbol(hostVar, Decl(consumer.ts, 1, 3)) >host : Symbol(host, Decl(consumer.ts, 0, 0)) var v = new hostVar.Host(); ->v : Symbol(v, Decl(consumer.ts, 3, 3)) +>v : Symbol(v, Decl(consumer.ts, 2, 3)) >hostVar.Host : Symbol(host.Host, Decl(host.ts, 0, 0)) ->hostVar : Symbol(hostVar, Decl(consumer.ts, 2, 3)) +>hostVar : Symbol(hostVar, Decl(consumer.ts, 1, 3)) >Host : Symbol(host.Host, Decl(host.ts, 0, 0)) === tests/cases/compiler/host.ts === diff --git a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.types b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.types index 137b339347a63..a7eeda0299daa 100644 --- a/tests/baselines/reference/import_var-referencing-an-imported-module-alias.types +++ b/tests/baselines/reference/import_var-referencing-an-imported-module-alias.types @@ -1,5 +1,4 @@ === tests/cases/compiler/consumer.ts === - import host = require("host"); >host : typeof host diff --git a/tests/baselines/reference/importsImplicitlyReadonly.errors.txt b/tests/baselines/reference/importsImplicitlyReadonly.errors.txt index 43596ffcea32e..aad8480a77a49 100644 --- a/tests/baselines/reference/importsImplicitlyReadonly.errors.txt +++ b/tests/baselines/reference/importsImplicitlyReadonly.errors.txt @@ -27,7 +27,6 @@ tests/cases/conformance/externalModules/b.ts(9,4): error TS2540: Cannot assign t a3.x = 1; a3.y = 1; ==== tests/cases/conformance/externalModules/a.ts (0 errors) ==== - export var x = 1; var y = 1; export { y }; diff --git a/tests/baselines/reference/importsImplicitlyReadonly.js b/tests/baselines/reference/importsImplicitlyReadonly.js index dd45d4db89c64..724b8c14e5322 100644 --- a/tests/baselines/reference/importsImplicitlyReadonly.js +++ b/tests/baselines/reference/importsImplicitlyReadonly.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/externalModules/importsImplicitlyReadonly.ts] //// //// [a.ts] - export var x = 1; var y = 1; export { y }; diff --git a/tests/baselines/reference/importsInAmbientModules1.js b/tests/baselines/reference/importsInAmbientModules1.js index 4c888f2dfe55c..da5dcce74f279 100644 --- a/tests/baselines/reference/importsInAmbientModules1.js +++ b/tests/baselines/reference/importsInAmbientModules1.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/importsInAmbientModules1.ts] //// //// [external.d.ts] - export var x: number //// [main.ts] - declare module "M" { import {x} from "external" } diff --git a/tests/baselines/reference/importsInAmbientModules1.symbols b/tests/baselines/reference/importsInAmbientModules1.symbols index d220ba2bf4543..4622747eceec0 100644 --- a/tests/baselines/reference/importsInAmbientModules1.symbols +++ b/tests/baselines/reference/importsInAmbientModules1.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export var x: number ->x : Symbol(x, Decl(external.d.ts, 1, 10)) +>x : Symbol(x, Decl(external.d.ts, 0, 10)) === tests/cases/compiler/main.ts === - declare module "M" { import {x} from "external" ->x : Symbol(x, Decl(main.ts, 2, 12)) +>x : Symbol(x, Decl(main.ts, 1, 12)) } diff --git a/tests/baselines/reference/importsInAmbientModules1.types b/tests/baselines/reference/importsInAmbientModules1.types index 634de9f1f0f4a..1d3aa843c9ca3 100644 --- a/tests/baselines/reference/importsInAmbientModules1.types +++ b/tests/baselines/reference/importsInAmbientModules1.types @@ -1,10 +1,8 @@ === tests/cases/compiler/external.d.ts === - export var x: number >x : number === tests/cases/compiler/main.ts === - declare module "M" { import {x} from "external" >x : number diff --git a/tests/baselines/reference/importsInAmbientModules2.js b/tests/baselines/reference/importsInAmbientModules2.js index 84d5dd84f104c..4f1a9d54e3720 100644 --- a/tests/baselines/reference/importsInAmbientModules2.js +++ b/tests/baselines/reference/importsInAmbientModules2.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/importsInAmbientModules2.ts] //// //// [external.d.ts] - export default class C {} //// [main.ts] - declare module "M" { import C from "external" } diff --git a/tests/baselines/reference/importsInAmbientModules2.symbols b/tests/baselines/reference/importsInAmbientModules2.symbols index 02333798e8b32..68d5bb210aadf 100644 --- a/tests/baselines/reference/importsInAmbientModules2.symbols +++ b/tests/baselines/reference/importsInAmbientModules2.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/external.d.ts === - export default class C {} >C : Symbol(C, Decl(external.d.ts, 0, 0)) === tests/cases/compiler/main.ts === - declare module "M" { import C from "external" ->C : Symbol(C, Decl(main.ts, 2, 10)) +>C : Symbol(C, Decl(main.ts, 1, 10)) } diff --git a/tests/baselines/reference/importsInAmbientModules2.types b/tests/baselines/reference/importsInAmbientModules2.types index d6c4eddc07c27..93dda11f672db 100644 --- a/tests/baselines/reference/importsInAmbientModules2.types +++ b/tests/baselines/reference/importsInAmbientModules2.types @@ -1,10 +1,8 @@ === tests/cases/compiler/external.d.ts === - export default class C {} >C : C === tests/cases/compiler/main.ts === - declare module "M" { import C from "external" >C : typeof C diff --git a/tests/baselines/reference/importsInAmbientModules3.js b/tests/baselines/reference/importsInAmbientModules3.js index 2a8e09b53e189..5539b5e8397e3 100644 --- a/tests/baselines/reference/importsInAmbientModules3.js +++ b/tests/baselines/reference/importsInAmbientModules3.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/importsInAmbientModules3.ts] //// //// [external.d.ts] - export default class C {} //// [main.ts] - declare module "M" { import C = require("external"); } diff --git a/tests/baselines/reference/importsInAmbientModules3.symbols b/tests/baselines/reference/importsInAmbientModules3.symbols index 15b2c7173dcaa..b75ba644a05d7 100644 --- a/tests/baselines/reference/importsInAmbientModules3.symbols +++ b/tests/baselines/reference/importsInAmbientModules3.symbols @@ -1,11 +1,9 @@ === tests/cases/compiler/main.ts === - declare module "M" { import C = require("external"); ->C : Symbol(C, Decl(main.ts, 1, 20)) +>C : Symbol(C, Decl(main.ts, 0, 20)) } === tests/cases/compiler/external.d.ts === - export default class C {} >C : Symbol(C, Decl(external.d.ts, 0, 0)) diff --git a/tests/baselines/reference/importsInAmbientModules3.types b/tests/baselines/reference/importsInAmbientModules3.types index 6c613687b0839..a9b19b19fbcae 100644 --- a/tests/baselines/reference/importsInAmbientModules3.types +++ b/tests/baselines/reference/importsInAmbientModules3.types @@ -1,11 +1,9 @@ === tests/cases/compiler/main.ts === - declare module "M" { import C = require("external"); >C : typeof C } === tests/cases/compiler/external.d.ts === - export default class C {} >C : C diff --git a/tests/baselines/reference/incompatibleGenericTypes.errors.txt b/tests/baselines/reference/incompatibleGenericTypes.errors.txt index e5dc6ed5b3c25..119d3b41f3dc1 100644 --- a/tests/baselines/reference/incompatibleGenericTypes.errors.txt +++ b/tests/baselines/reference/incompatibleGenericTypes.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/incompatibleGenericTypes.ts(10,5): error TS2322: Type 'I1' is not assignable to type 'I1'. +tests/cases/compiler/incompatibleGenericTypes.ts(9,5): error TS2322: Type 'I1' is not assignable to type 'I1'. Type 'boolean' is not assignable to type 'number'. ==== tests/cases/compiler/incompatibleGenericTypes.ts (1 errors) ==== - interface I1 { m1(callback: (p: T) => U): I1; diff --git a/tests/baselines/reference/incompatibleGenericTypes.js b/tests/baselines/reference/incompatibleGenericTypes.js index 21a2dbc5e4143..633007497fab7 100644 --- a/tests/baselines/reference/incompatibleGenericTypes.js +++ b/tests/baselines/reference/incompatibleGenericTypes.js @@ -1,5 +1,4 @@ //// [incompatibleGenericTypes.ts] - interface I1 { m1(callback: (p: T) => U): I1; diff --git a/tests/baselines/reference/indexedAccessRelation.js b/tests/baselines/reference/indexedAccessRelation.js new file mode 100644 index 0000000000000..10384c9eacd28 --- /dev/null +++ b/tests/baselines/reference/indexedAccessRelation.js @@ -0,0 +1,56 @@ +//// [indexedAccessRelation.ts] +// Repro from #14723 + +class Component { + setState(state: Pick) {} +} + +export interface State { + a?: T; +} + +class Foo {} + +class Comp extends Component> +{ + foo(a: T) { + this.setState({ a: a }); + } +} + + +//// [indexedAccessRelation.js] +"use strict"; +// Repro from #14723 +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +exports.__esModule = true; +var Component = (function () { + function Component() { + } + Component.prototype.setState = function (state) { }; + return Component; +}()); +var Foo = (function () { + function Foo() { + } + return Foo; +}()); +var Comp = (function (_super) { + __extends(Comp, _super); + function Comp() { + return _super !== null && _super.apply(this, arguments) || this; + } + Comp.prototype.foo = function (a) { + this.setState({ a: a }); + }; + return Comp; +}(Component)); diff --git a/tests/baselines/reference/indexedAccessRelation.symbols b/tests/baselines/reference/indexedAccessRelation.symbols new file mode 100644 index 0000000000000..40fa52652f956 --- /dev/null +++ b/tests/baselines/reference/indexedAccessRelation.symbols @@ -0,0 +1,53 @@ +=== tests/cases/compiler/indexedAccessRelation.ts === +// Repro from #14723 + +class Component { +>Component : Symbol(Component, Decl(indexedAccessRelation.ts, 0, 0)) +>S : Symbol(S, Decl(indexedAccessRelation.ts, 2, 16)) + + setState(state: Pick) {} +>setState : Symbol(Component.setState, Decl(indexedAccessRelation.ts, 2, 20)) +>K : Symbol(K, Decl(indexedAccessRelation.ts, 3, 13)) +>S : Symbol(S, Decl(indexedAccessRelation.ts, 2, 16)) +>state : Symbol(state, Decl(indexedAccessRelation.ts, 3, 32)) +>Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) +>S : Symbol(S, Decl(indexedAccessRelation.ts, 2, 16)) +>K : Symbol(K, Decl(indexedAccessRelation.ts, 3, 13)) +} + +export interface State { +>State : Symbol(State, Decl(indexedAccessRelation.ts, 4, 1)) +>T : Symbol(T, Decl(indexedAccessRelation.ts, 6, 23)) + + a?: T; +>a : Symbol(State.a, Decl(indexedAccessRelation.ts, 6, 27)) +>T : Symbol(T, Decl(indexedAccessRelation.ts, 6, 23)) +} + +class Foo {} +>Foo : Symbol(Foo, Decl(indexedAccessRelation.ts, 8, 1)) + +class Comp extends Component> +>Comp : Symbol(Comp, Decl(indexedAccessRelation.ts, 10, 12)) +>T : Symbol(T, Decl(indexedAccessRelation.ts, 12, 11)) +>Foo : Symbol(Foo, Decl(indexedAccessRelation.ts, 8, 1)) +>S : Symbol(S, Decl(indexedAccessRelation.ts, 12, 25)) +>Component : Symbol(Component, Decl(indexedAccessRelation.ts, 0, 0)) +>S : Symbol(S, Decl(indexedAccessRelation.ts, 12, 25)) +>State : Symbol(State, Decl(indexedAccessRelation.ts, 4, 1)) +>T : Symbol(T, Decl(indexedAccessRelation.ts, 12, 11)) +{ + foo(a: T) { +>foo : Symbol(Comp.foo, Decl(indexedAccessRelation.ts, 13, 1)) +>a : Symbol(a, Decl(indexedAccessRelation.ts, 14, 8)) +>T : Symbol(T, Decl(indexedAccessRelation.ts, 12, 11)) + + this.setState({ a: a }); +>this.setState : Symbol(Component.setState, Decl(indexedAccessRelation.ts, 2, 20)) +>this : Symbol(Comp, Decl(indexedAccessRelation.ts, 10, 12)) +>setState : Symbol(Component.setState, Decl(indexedAccessRelation.ts, 2, 20)) +>a : Symbol(a, Decl(indexedAccessRelation.ts, 15, 23)) +>a : Symbol(a, Decl(indexedAccessRelation.ts, 14, 8)) + } +} + diff --git a/tests/baselines/reference/indexedAccessRelation.types b/tests/baselines/reference/indexedAccessRelation.types new file mode 100644 index 0000000000000..2564a82702dd6 --- /dev/null +++ b/tests/baselines/reference/indexedAccessRelation.types @@ -0,0 +1,55 @@ +=== tests/cases/compiler/indexedAccessRelation.ts === +// Repro from #14723 + +class Component { +>Component : Component +>S : S + + setState(state: Pick) {} +>setState : (state: Pick) => void +>K : K +>S : S +>state : Pick +>Pick : Pick +>S : S +>K : K +} + +export interface State { +>State : State +>T : T + + a?: T; +>a : T +>T : T +} + +class Foo {} +>Foo : Foo + +class Comp extends Component> +>Comp : Comp +>T : T +>Foo : Foo +>S : S +>Component : Component> +>S : S +>State : State +>T : T +{ + foo(a: T) { +>foo : (a: T) => void +>a : T +>T : T + + this.setState({ a: a }); +>this.setState({ a: a }) : void +>this.setState : )>(state: Pick, K>) => void +>this : this +>setState : )>(state: Pick, K>) => void +>{ a: a } : { a: T; } +>a : T +>a : T + } +} + diff --git a/tests/baselines/reference/indexedAccessTypeConstraints.js b/tests/baselines/reference/indexedAccessTypeConstraints.js index ec9af906e4337..075e93dfa2353 100644 --- a/tests/baselines/reference/indexedAccessTypeConstraints.js +++ b/tests/baselines/reference/indexedAccessTypeConstraints.js @@ -1,5 +1,4 @@ //// [indexedAccessTypeConstraints.ts] - // Repro from #14557 interface IData { @@ -37,8 +36,8 @@ function foo(x: C, y: T['content']) { //// [indexedAccessTypeConstraints.js] -// Repro from #14557 "use strict"; +// Repro from #14557 var __extends = (this && this.__extends) || (function () { var extendStatics = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || diff --git a/tests/baselines/reference/indexedAccessTypeConstraints.symbols b/tests/baselines/reference/indexedAccessTypeConstraints.symbols index b2d10c7ee2768..6d81534aa2625 100644 --- a/tests/baselines/reference/indexedAccessTypeConstraints.symbols +++ b/tests/baselines/reference/indexedAccessTypeConstraints.symbols @@ -1,109 +1,108 @@ === tests/cases/compiler/indexedAccessTypeConstraints.ts === - // Repro from #14557 interface IData { >IData : Symbol(IData, Decl(indexedAccessTypeConstraints.ts, 0, 0)) ->T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 3, 16)) +>T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 2, 16)) content: T; ->content : Symbol(IData.content, Decl(indexedAccessTypeConstraints.ts, 3, 20)) ->T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 3, 16)) +>content : Symbol(IData.content, Decl(indexedAccessTypeConstraints.ts, 2, 20)) +>T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 2, 16)) } type Data = { ->Data : Symbol(Data, Decl(indexedAccessTypeConstraints.ts, 5, 1)) ->T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 7, 10)) +>Data : Symbol(Data, Decl(indexedAccessTypeConstraints.ts, 4, 1)) +>T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 6, 10)) get: (prop: K) => T[K]; ->get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 7, 16)) ->K : Symbol(K, Decl(indexedAccessTypeConstraints.ts, 8, 10)) ->T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 7, 10)) ->prop : Symbol(prop, Decl(indexedAccessTypeConstraints.ts, 8, 29)) ->K : Symbol(K, Decl(indexedAccessTypeConstraints.ts, 8, 10)) ->T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 7, 10)) ->K : Symbol(K, Decl(indexedAccessTypeConstraints.ts, 8, 10)) +>get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16)) +>K : Symbol(K, Decl(indexedAccessTypeConstraints.ts, 7, 10)) +>T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 6, 10)) +>prop : Symbol(prop, Decl(indexedAccessTypeConstraints.ts, 7, 29)) +>K : Symbol(K, Decl(indexedAccessTypeConstraints.ts, 7, 10)) +>T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 6, 10)) +>K : Symbol(K, Decl(indexedAccessTypeConstraints.ts, 7, 10)) }; class Parent { ->Parent : Symbol(Parent, Decl(indexedAccessTypeConstraints.ts, 9, 2)) ->M : Symbol(M, Decl(indexedAccessTypeConstraints.ts, 11, 13)) +>Parent : Symbol(Parent, Decl(indexedAccessTypeConstraints.ts, 8, 2)) +>M : Symbol(M, Decl(indexedAccessTypeConstraints.ts, 10, 13)) private data: Data; ->data : Symbol(Parent.data, Decl(indexedAccessTypeConstraints.ts, 11, 17)) ->Data : Symbol(Data, Decl(indexedAccessTypeConstraints.ts, 5, 1)) ->M : Symbol(M, Decl(indexedAccessTypeConstraints.ts, 11, 13)) +>data : Symbol(Parent.data, Decl(indexedAccessTypeConstraints.ts, 10, 17)) +>Data : Symbol(Data, Decl(indexedAccessTypeConstraints.ts, 4, 1)) +>M : Symbol(M, Decl(indexedAccessTypeConstraints.ts, 10, 13)) getData(): Data { ->getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 12, 26)) ->Data : Symbol(Data, Decl(indexedAccessTypeConstraints.ts, 5, 1)) ->M : Symbol(M, Decl(indexedAccessTypeConstraints.ts, 11, 13)) +>getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 11, 26)) +>Data : Symbol(Data, Decl(indexedAccessTypeConstraints.ts, 4, 1)) +>M : Symbol(M, Decl(indexedAccessTypeConstraints.ts, 10, 13)) return this.data; ->this.data : Symbol(Parent.data, Decl(indexedAccessTypeConstraints.ts, 11, 17)) ->this : Symbol(Parent, Decl(indexedAccessTypeConstraints.ts, 9, 2)) ->data : Symbol(Parent.data, Decl(indexedAccessTypeConstraints.ts, 11, 17)) +>this.data : Symbol(Parent.data, Decl(indexedAccessTypeConstraints.ts, 10, 17)) +>this : Symbol(Parent, Decl(indexedAccessTypeConstraints.ts, 8, 2)) +>data : Symbol(Parent.data, Decl(indexedAccessTypeConstraints.ts, 10, 17)) } } export class Foo extends Parent> { ->Foo : Symbol(Foo, Decl(indexedAccessTypeConstraints.ts, 16, 1)) ->C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 18, 17)) ->Parent : Symbol(Parent, Decl(indexedAccessTypeConstraints.ts, 9, 2)) +>Foo : Symbol(Foo, Decl(indexedAccessTypeConstraints.ts, 15, 1)) +>C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 17, 17)) +>Parent : Symbol(Parent, Decl(indexedAccessTypeConstraints.ts, 8, 2)) >IData : Symbol(IData, Decl(indexedAccessTypeConstraints.ts, 0, 0)) ->C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 18, 17)) +>C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 17, 17)) getContent(): C { ->getContent : Symbol(Foo.getContent, Decl(indexedAccessTypeConstraints.ts, 18, 46)) ->C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 18, 17)) +>getContent : Symbol(Foo.getContent, Decl(indexedAccessTypeConstraints.ts, 17, 46)) +>C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 17, 17)) return this.getData().get('content'); ->this.getData().get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 7, 16)) ->this.getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 12, 26)) ->this : Symbol(Foo, Decl(indexedAccessTypeConstraints.ts, 16, 1)) ->getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 12, 26)) ->get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 7, 16)) +>this.getData().get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16)) +>this.getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 11, 26)) +>this : Symbol(Foo, Decl(indexedAccessTypeConstraints.ts, 15, 1)) +>getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 11, 26)) +>get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16)) } } export class Bar> extends Parent { ->Bar : Symbol(Bar, Decl(indexedAccessTypeConstraints.ts, 22, 1)) ->C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 24, 17)) ->T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 24, 19)) +>Bar : Symbol(Bar, Decl(indexedAccessTypeConstraints.ts, 21, 1)) +>C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 23, 17)) +>T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 23, 19)) >IData : Symbol(IData, Decl(indexedAccessTypeConstraints.ts, 0, 0)) ->C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 24, 17)) ->Parent : Symbol(Parent, Decl(indexedAccessTypeConstraints.ts, 9, 2)) ->T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 24, 19)) +>C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 23, 17)) +>Parent : Symbol(Parent, Decl(indexedAccessTypeConstraints.ts, 8, 2)) +>T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 23, 19)) getContent(): C { ->getContent : Symbol(Bar.getContent, Decl(indexedAccessTypeConstraints.ts, 24, 59)) ->C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 24, 17)) +>getContent : Symbol(Bar.getContent, Decl(indexedAccessTypeConstraints.ts, 23, 59)) +>C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 23, 17)) return this.getData().get('content'); ->this.getData().get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 7, 16)) ->this.getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 12, 26)) ->this : Symbol(Bar, Decl(indexedAccessTypeConstraints.ts, 22, 1)) ->getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 12, 26)) ->get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 7, 16)) +>this.getData().get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16)) +>this.getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 11, 26)) +>this : Symbol(Bar, Decl(indexedAccessTypeConstraints.ts, 21, 1)) +>getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 11, 26)) +>get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16)) } } // Repro from #14557 function foo(x: C, y: T['content']) { ->foo : Symbol(foo, Decl(indexedAccessTypeConstraints.ts, 28, 1)) ->C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 32, 13)) ->T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 32, 15)) ->content : Symbol(content, Decl(indexedAccessTypeConstraints.ts, 32, 27)) ->C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 32, 13)) ->x : Symbol(x, Decl(indexedAccessTypeConstraints.ts, 32, 42)) ->C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 32, 13)) ->y : Symbol(y, Decl(indexedAccessTypeConstraints.ts, 32, 47)) ->T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 32, 15)) +>foo : Symbol(foo, Decl(indexedAccessTypeConstraints.ts, 27, 1)) +>C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 31, 13)) +>T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 31, 15)) +>content : Symbol(content, Decl(indexedAccessTypeConstraints.ts, 31, 27)) +>C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 31, 13)) +>x : Symbol(x, Decl(indexedAccessTypeConstraints.ts, 31, 42)) +>C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 31, 13)) +>y : Symbol(y, Decl(indexedAccessTypeConstraints.ts, 31, 47)) +>T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 31, 15)) x = y; ->x : Symbol(x, Decl(indexedAccessTypeConstraints.ts, 32, 42)) ->y : Symbol(y, Decl(indexedAccessTypeConstraints.ts, 32, 47)) +>x : Symbol(x, Decl(indexedAccessTypeConstraints.ts, 31, 42)) +>y : Symbol(y, Decl(indexedAccessTypeConstraints.ts, 31, 47)) } diff --git a/tests/baselines/reference/indexedAccessTypeConstraints.types b/tests/baselines/reference/indexedAccessTypeConstraints.types index 5a2cbc4933fd0..c7373fe5d4b9c 100644 --- a/tests/baselines/reference/indexedAccessTypeConstraints.types +++ b/tests/baselines/reference/indexedAccessTypeConstraints.types @@ -1,5 +1,4 @@ === tests/cases/compiler/indexedAccessTypeConstraints.ts === - // Repro from #14557 interface IData { diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.js b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.js index 018726f554917..2f5eea63a8af1 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.js +++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.js @@ -1,5 +1,4 @@ //// [inferentialTypingWithFunctionTypeSyntacticScenarios.ts] - declare function map(array: T, func: (x: T) => U): U; declare function identity(y: V): V; var s: string; diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols index 1ad418cb5995f..a9571bc8a388d 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols +++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols @@ -1,95 +1,94 @@ === tests/cases/compiler/inferentialTypingWithFunctionTypeSyntacticScenarios.ts === - declare function map(array: T, func: (x: T) => U): U; >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 21)) ->U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 23)) ->array : Symbol(array, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 27)) ->T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 21)) ->func : Symbol(func, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 36)) ->x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 44)) ->T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 21)) ->U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 23)) ->U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 23)) +>T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 21)) +>U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 23)) +>array : Symbol(array, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 27)) +>T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 21)) +>func : Symbol(func, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 36)) +>x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 44)) +>T : Symbol(T, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 21)) +>U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 23)) +>U : Symbol(U, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 23)) declare function identity(y: V): V; ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) ->V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 26)) ->y : Symbol(y, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 29)) ->V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 26)) ->V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 26)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) +>V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 26)) +>y : Symbol(y, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 29)) +>V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 26)) +>V : Symbol(V, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 26)) var s: string; ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) // dotted name var dottedIdentity = { x: identity }; ->dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 3)) ->x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 22)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 3)) +>x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) s = map("", dottedIdentity.x); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->dottedIdentity.x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 22)) ->dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 3)) ->x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 22)) +>dottedIdentity.x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22)) +>dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 3)) +>x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22)) // index expression s = map("", dottedIdentity['x']); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 3)) ->'x' : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 6, 22)) +>dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 3)) +>'x' : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22)) // function call s = map("", (() => identity)()); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) // construct interface IdentityConstructor { ->IdentityConstructor : Symbol(IdentityConstructor, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 13, 32)) +>IdentityConstructor : Symbol(IdentityConstructor, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 12, 32)) new (): typeof identity; ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) } var ic: IdentityConstructor; ->ic : Symbol(ic, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 19, 3)) ->IdentityConstructor : Symbol(IdentityConstructor, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 13, 32)) +>ic : Symbol(ic, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 18, 3)) +>IdentityConstructor : Symbol(IdentityConstructor, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 12, 32)) s = map("", new ic()); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->ic : Symbol(ic, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 19, 3)) +>ic : Symbol(ic, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 18, 3)) // assignment var t; ->t : Symbol(t, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 23, 3)) +>t : Symbol(t, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 22, 3)) s = map("", t = identity); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->t : Symbol(t, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 23, 3)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>t : Symbol(t, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 22, 3)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) // type assertion s = map("", identity); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) // parenthesized expression s = map("", (identity)); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) // comma s = map("", ("", identity)); ->s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 3, 3)) +>s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3)) >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0)) ->identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 1, 59)) +>identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59)) diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.types b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.types index 258b4cbfa46fe..cb7904b80603e 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.types +++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.types @@ -1,5 +1,4 @@ === tests/cases/compiler/inferentialTypingWithFunctionTypeSyntacticScenarios.ts === - declare function map(array: T, func: (x: T) => U): U; >map : (array: T, func: (x: T) => U) => U >T : T diff --git a/tests/baselines/reference/inferingFromAny.symbols b/tests/baselines/reference/inferingFromAny.symbols index cabb8fb07b7d6..4622d1ce574c6 100644 --- a/tests/baselines/reference/inferingFromAny.symbols +++ b/tests/baselines/reference/inferingFromAny.symbols @@ -1,102 +1,111 @@ === tests/cases/conformance/salsa/a.ts === - var a: any; ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var t: [any, any]; ->t : Symbol(t, Decl(a.ts, 2, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) +>t : Symbol(t, Decl(a.ts, 1, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) declare function f1(t: T): T ->f1 : Symbol(f1, Decl(a.ts, 2, 18)) +>f1 : Symbol(f1, Decl(a.ts, 1, 18)) +>T : Symbol(T, Decl(a.ts, 2, 20)) +>t : Symbol(t, Decl(a.ts, 2, 23)) +>T : Symbol(T, Decl(a.ts, 2, 20)) +>T : Symbol(T, Decl(a.ts, 2, 20)) + +declare function f2(t: T[]): T; +>f2 : Symbol(f2, Decl(a.ts, 2, 31)) >T : Symbol(T, Decl(a.ts, 3, 20)) >t : Symbol(t, Decl(a.ts, 3, 23)) >T : Symbol(T, Decl(a.ts, 3, 20)) >T : Symbol(T, Decl(a.ts, 3, 20)) -declare function f2(t: T[]): T; ->f2 : Symbol(f2, Decl(a.ts, 3, 31)) +declare function f3(t: [T, U]): [T, U]; +>f3 : Symbol(f3, Decl(a.ts, 3, 34)) >T : Symbol(T, Decl(a.ts, 4, 20)) ->t : Symbol(t, Decl(a.ts, 4, 23)) +>U : Symbol(U, Decl(a.ts, 4, 22)) +>t : Symbol(t, Decl(a.ts, 4, 26)) >T : Symbol(T, Decl(a.ts, 4, 20)) +>U : Symbol(U, Decl(a.ts, 4, 22)) >T : Symbol(T, Decl(a.ts, 4, 20)) +>U : Symbol(U, Decl(a.ts, 4, 22)) -declare function f3(t: [T, U]): [T, U]; ->f3 : Symbol(f3, Decl(a.ts, 4, 34)) +declare function f4(x: { bar: T; baz: T }): T; +>f4 : Symbol(f4, Decl(a.ts, 4, 45)) +>T : Symbol(T, Decl(a.ts, 5, 20)) +>x : Symbol(x, Decl(a.ts, 5, 23)) +>bar : Symbol(bar, Decl(a.ts, 5, 27)) >T : Symbol(T, Decl(a.ts, 5, 20)) ->U : Symbol(U, Decl(a.ts, 5, 22)) ->t : Symbol(t, Decl(a.ts, 5, 26)) +>baz : Symbol(baz, Decl(a.ts, 5, 35)) >T : Symbol(T, Decl(a.ts, 5, 20)) ->U : Symbol(U, Decl(a.ts, 5, 22)) >T : Symbol(T, Decl(a.ts, 5, 20)) ->U : Symbol(U, Decl(a.ts, 5, 22)) -declare function f4(x: { bar: T; baz: T }): T; ->f4 : Symbol(f4, Decl(a.ts, 5, 45)) +declare function f5(x: (a: T) => void): T; +>f5 : Symbol(f5, Decl(a.ts, 5, 49)) >T : Symbol(T, Decl(a.ts, 6, 20)) >x : Symbol(x, Decl(a.ts, 6, 23)) ->bar : Symbol(bar, Decl(a.ts, 6, 27)) ->T : Symbol(T, Decl(a.ts, 6, 20)) ->baz : Symbol(baz, Decl(a.ts, 6, 35)) +>a : Symbol(a, Decl(a.ts, 6, 27)) >T : Symbol(T, Decl(a.ts, 6, 20)) >T : Symbol(T, Decl(a.ts, 6, 20)) -declare function f5(x: (a: T) => void): T; ->f5 : Symbol(f5, Decl(a.ts, 6, 49)) +declare function f6(x: new (a: T) => {}): T; +>f6 : Symbol(f6, Decl(a.ts, 6, 45)) >T : Symbol(T, Decl(a.ts, 7, 20)) >x : Symbol(x, Decl(a.ts, 7, 23)) ->a : Symbol(a, Decl(a.ts, 7, 27)) +>a : Symbol(a, Decl(a.ts, 7, 31)) >T : Symbol(T, Decl(a.ts, 7, 20)) >T : Symbol(T, Decl(a.ts, 7, 20)) -declare function f6(x: new (a: T) => {}): T; ->f6 : Symbol(f6, Decl(a.ts, 7, 45)) +declare function f7(x: (a: any) => a is T): T; +>f7 : Symbol(f7, Decl(a.ts, 7, 47)) >T : Symbol(T, Decl(a.ts, 8, 20)) >x : Symbol(x, Decl(a.ts, 8, 23)) ->a : Symbol(a, Decl(a.ts, 8, 31)) +>a : Symbol(a, Decl(a.ts, 8, 27)) +>a : Symbol(a, Decl(a.ts, 8, 27)) >T : Symbol(T, Decl(a.ts, 8, 20)) >T : Symbol(T, Decl(a.ts, 8, 20)) -declare function f7(x: (a: any) => a is T): T; ->f7 : Symbol(f7, Decl(a.ts, 8, 47)) +declare function f8(x: () => T): T; +>f8 : Symbol(f8, Decl(a.ts, 8, 49)) >T : Symbol(T, Decl(a.ts, 9, 20)) >x : Symbol(x, Decl(a.ts, 9, 23)) ->a : Symbol(a, Decl(a.ts, 9, 27)) ->a : Symbol(a, Decl(a.ts, 9, 27)) >T : Symbol(T, Decl(a.ts, 9, 20)) >T : Symbol(T, Decl(a.ts, 9, 20)) -declare function f8(x: () => T): T; ->f8 : Symbol(f8, Decl(a.ts, 9, 49)) +declare function f9(x: new () => T): T; +>f9 : Symbol(f9, Decl(a.ts, 9, 38)) >T : Symbol(T, Decl(a.ts, 10, 20)) >x : Symbol(x, Decl(a.ts, 10, 23)) >T : Symbol(T, Decl(a.ts, 10, 20)) >T : Symbol(T, Decl(a.ts, 10, 20)) -declare function f9(x: new () => T): T; ->f9 : Symbol(f9, Decl(a.ts, 10, 38)) ->T : Symbol(T, Decl(a.ts, 11, 20)) ->x : Symbol(x, Decl(a.ts, 11, 23)) ->T : Symbol(T, Decl(a.ts, 11, 20)) ->T : Symbol(T, Decl(a.ts, 11, 20)) - declare function f10(x: { [x: string]: T }): T; ->f10 : Symbol(f10, Decl(a.ts, 11, 42)) +>f10 : Symbol(f10, Decl(a.ts, 10, 42)) +>T : Symbol(T, Decl(a.ts, 11, 21)) +>x : Symbol(x, Decl(a.ts, 11, 24)) +>x : Symbol(x, Decl(a.ts, 11, 30)) +>T : Symbol(T, Decl(a.ts, 11, 21)) +>T : Symbol(T, Decl(a.ts, 11, 21)) + +declare function f11(x: { [x: number]: T }): T; +>f11 : Symbol(f11, Decl(a.ts, 11, 50)) >T : Symbol(T, Decl(a.ts, 12, 21)) >x : Symbol(x, Decl(a.ts, 12, 24)) >x : Symbol(x, Decl(a.ts, 12, 30)) >T : Symbol(T, Decl(a.ts, 12, 21)) >T : Symbol(T, Decl(a.ts, 12, 21)) -declare function f11(x: { [x: number]: T }): T; ->f11 : Symbol(f11, Decl(a.ts, 12, 50)) +declare function f12(x: T | U): [T, U]; +>f12 : Symbol(f12, Decl(a.ts, 12, 50)) >T : Symbol(T, Decl(a.ts, 13, 21)) ->x : Symbol(x, Decl(a.ts, 13, 24)) ->x : Symbol(x, Decl(a.ts, 13, 30)) +>U : Symbol(U, Decl(a.ts, 13, 23)) +>x : Symbol(x, Decl(a.ts, 13, 27)) >T : Symbol(T, Decl(a.ts, 13, 21)) +>U : Symbol(U, Decl(a.ts, 13, 23)) >T : Symbol(T, Decl(a.ts, 13, 21)) +>U : Symbol(U, Decl(a.ts, 13, 23)) -declare function f12(x: T | U): [T, U]; ->f12 : Symbol(f12, Decl(a.ts, 13, 50)) +declare function f13(x: T & U): [T, U]; +>f13 : Symbol(f13, Decl(a.ts, 13, 45)) >T : Symbol(T, Decl(a.ts, 14, 21)) >U : Symbol(U, Decl(a.ts, 14, 23)) >x : Symbol(x, Decl(a.ts, 14, 27)) @@ -105,178 +114,168 @@ declare function f12(x: T | U): [T, U]; >T : Symbol(T, Decl(a.ts, 14, 21)) >U : Symbol(U, Decl(a.ts, 14, 23)) -declare function f13(x: T & U): [T, U]; ->f13 : Symbol(f13, Decl(a.ts, 14, 45)) +declare function f14(x: { a: T | U, b: U & T }): [T, U]; +>f14 : Symbol(f14, Decl(a.ts, 14, 45)) >T : Symbol(T, Decl(a.ts, 15, 21)) >U : Symbol(U, Decl(a.ts, 15, 23)) >x : Symbol(x, Decl(a.ts, 15, 27)) +>a : Symbol(a, Decl(a.ts, 15, 31)) >T : Symbol(T, Decl(a.ts, 15, 21)) >U : Symbol(U, Decl(a.ts, 15, 23)) +>b : Symbol(b, Decl(a.ts, 15, 41)) +>U : Symbol(U, Decl(a.ts, 15, 23)) +>T : Symbol(T, Decl(a.ts, 15, 21)) >T : Symbol(T, Decl(a.ts, 15, 21)) >U : Symbol(U, Decl(a.ts, 15, 23)) -declare function f14(x: { a: T | U, b: U & T }): [T, U]; ->f14 : Symbol(f14, Decl(a.ts, 15, 45)) ->T : Symbol(T, Decl(a.ts, 16, 21)) ->U : Symbol(U, Decl(a.ts, 16, 23)) ->x : Symbol(x, Decl(a.ts, 16, 27)) ->a : Symbol(a, Decl(a.ts, 16, 31)) ->T : Symbol(T, Decl(a.ts, 16, 21)) ->U : Symbol(U, Decl(a.ts, 16, 23)) ->b : Symbol(b, Decl(a.ts, 16, 41)) ->U : Symbol(U, Decl(a.ts, 16, 23)) ->T : Symbol(T, Decl(a.ts, 16, 21)) ->T : Symbol(T, Decl(a.ts, 16, 21)) ->U : Symbol(U, Decl(a.ts, 16, 23)) - interface I { } ->I : Symbol(I, Decl(a.ts, 16, 62)) ->T : Symbol(T, Decl(a.ts, 17, 12)) +>I : Symbol(I, Decl(a.ts, 15, 62)) +>T : Symbol(T, Decl(a.ts, 16, 12)) declare function f15(x: I): T; ->f15 : Symbol(f15, Decl(a.ts, 17, 18)) +>f15 : Symbol(f15, Decl(a.ts, 16, 18)) +>T : Symbol(T, Decl(a.ts, 17, 21)) +>x : Symbol(x, Decl(a.ts, 17, 24)) +>I : Symbol(I, Decl(a.ts, 15, 62)) +>T : Symbol(T, Decl(a.ts, 17, 21)) +>T : Symbol(T, Decl(a.ts, 17, 21)) + +declare function f16(x: Partial): T; +>f16 : Symbol(f16, Decl(a.ts, 17, 36)) >T : Symbol(T, Decl(a.ts, 18, 21)) >x : Symbol(x, Decl(a.ts, 18, 24)) ->I : Symbol(I, Decl(a.ts, 16, 62)) +>Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(a.ts, 18, 21)) >T : Symbol(T, Decl(a.ts, 18, 21)) -declare function f16(x: Partial): T; ->f16 : Symbol(f16, Decl(a.ts, 18, 36)) +declare function f17(x: {[P in keyof T]: K}): T; +>f17 : Symbol(f17, Decl(a.ts, 18, 42)) >T : Symbol(T, Decl(a.ts, 19, 21)) ->x : Symbol(x, Decl(a.ts, 19, 24)) ->Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) +>K : Symbol(K, Decl(a.ts, 19, 23)) +>x : Symbol(x, Decl(a.ts, 19, 27)) +>P : Symbol(P, Decl(a.ts, 19, 32)) >T : Symbol(T, Decl(a.ts, 19, 21)) +>K : Symbol(K, Decl(a.ts, 19, 23)) >T : Symbol(T, Decl(a.ts, 19, 21)) -declare function f17(x: {[P in keyof T]: K}): T; ->f17 : Symbol(f17, Decl(a.ts, 19, 42)) +declare function f18(x: {[P in K]: T[P]}): T; +>f18 : Symbol(f18, Decl(a.ts, 19, 54)) >T : Symbol(T, Decl(a.ts, 20, 21)) >K : Symbol(K, Decl(a.ts, 20, 23)) ->x : Symbol(x, Decl(a.ts, 20, 27)) ->P : Symbol(P, Decl(a.ts, 20, 32)) >T : Symbol(T, Decl(a.ts, 20, 21)) +>x : Symbol(x, Decl(a.ts, 20, 43)) +>P : Symbol(P, Decl(a.ts, 20, 48)) >K : Symbol(K, Decl(a.ts, 20, 23)) >T : Symbol(T, Decl(a.ts, 20, 21)) +>P : Symbol(P, Decl(a.ts, 20, 48)) +>T : Symbol(T, Decl(a.ts, 20, 21)) -declare function f18(x: {[P in K]: T[P]}): T; ->f18 : Symbol(f18, Decl(a.ts, 20, 54)) +declare function f19(k: K, x: T[K]): T; +>f19 : Symbol(f19, Decl(a.ts, 20, 67)) >T : Symbol(T, Decl(a.ts, 21, 21)) >K : Symbol(K, Decl(a.ts, 21, 23)) >T : Symbol(T, Decl(a.ts, 21, 21)) ->x : Symbol(x, Decl(a.ts, 21, 43)) ->P : Symbol(P, Decl(a.ts, 21, 48)) +>k : Symbol(k, Decl(a.ts, 21, 43)) >K : Symbol(K, Decl(a.ts, 21, 23)) +>x : Symbol(x, Decl(a.ts, 21, 48)) >T : Symbol(T, Decl(a.ts, 21, 21)) ->P : Symbol(P, Decl(a.ts, 21, 48)) +>K : Symbol(K, Decl(a.ts, 21, 23)) >T : Symbol(T, Decl(a.ts, 21, 21)) -declare function f19(k: K, x: T[K]): T; ->f19 : Symbol(f19, Decl(a.ts, 21, 67)) ->T : Symbol(T, Decl(a.ts, 22, 21)) ->K : Symbol(K, Decl(a.ts, 22, 23)) ->T : Symbol(T, Decl(a.ts, 22, 21)) ->k : Symbol(k, Decl(a.ts, 22, 43)) ->K : Symbol(K, Decl(a.ts, 22, 23)) ->x : Symbol(x, Decl(a.ts, 22, 48)) ->T : Symbol(T, Decl(a.ts, 22, 21)) ->K : Symbol(K, Decl(a.ts, 22, 23)) ->T : Symbol(T, Decl(a.ts, 22, 21)) - === tests/cases/conformance/salsa/a.js === var a = f1(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f1 : Symbol(f1, Decl(a.ts, 2, 18)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f1 : Symbol(f1, Decl(a.ts, 1, 18)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f2(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f2 : Symbol(f2, Decl(a.ts, 3, 31)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f2 : Symbol(f2, Decl(a.ts, 2, 31)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var t = f3(a); ->t : Symbol(t, Decl(a.ts, 2, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) ->f3 : Symbol(f3, Decl(a.ts, 4, 34)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>t : Symbol(t, Decl(a.ts, 1, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) +>f3 : Symbol(f3, Decl(a.ts, 3, 34)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f4(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f4 : Symbol(f4, Decl(a.ts, 5, 45)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f4 : Symbol(f4, Decl(a.ts, 4, 45)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f5(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f5 : Symbol(f5, Decl(a.ts, 6, 49)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f5 : Symbol(f5, Decl(a.ts, 5, 49)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f6(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f6 : Symbol(f6, Decl(a.ts, 7, 45)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f6 : Symbol(f6, Decl(a.ts, 6, 45)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f7(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f7 : Symbol(f7, Decl(a.ts, 8, 47)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f7 : Symbol(f7, Decl(a.ts, 7, 47)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f8(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f8 : Symbol(f8, Decl(a.ts, 9, 49)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f8 : Symbol(f8, Decl(a.ts, 8, 49)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f9(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f9 : Symbol(f9, Decl(a.ts, 10, 38)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f9 : Symbol(f9, Decl(a.ts, 9, 38)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f10(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f10 : Symbol(f10, Decl(a.ts, 11, 42)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f10 : Symbol(f10, Decl(a.ts, 10, 42)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f11(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f11 : Symbol(f11, Decl(a.ts, 12, 50)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f11 : Symbol(f11, Decl(a.ts, 11, 50)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var t = f12(a); ->t : Symbol(t, Decl(a.ts, 2, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) ->f12 : Symbol(f12, Decl(a.ts, 13, 50)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>t : Symbol(t, Decl(a.ts, 1, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) +>f12 : Symbol(f12, Decl(a.ts, 12, 50)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var t = f13(a); ->t : Symbol(t, Decl(a.ts, 2, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) ->f13 : Symbol(f13, Decl(a.ts, 14, 45)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>t : Symbol(t, Decl(a.ts, 1, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) +>f13 : Symbol(f13, Decl(a.ts, 13, 45)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var t = f14(a); ->t : Symbol(t, Decl(a.ts, 2, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) ->f14 : Symbol(f14, Decl(a.ts, 15, 45)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>t : Symbol(t, Decl(a.ts, 1, 3), Decl(a.js, 2, 3), Decl(a.js, 11, 3), Decl(a.js, 12, 3), Decl(a.js, 13, 3)) +>f14 : Symbol(f14, Decl(a.ts, 14, 45)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f15(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f15 : Symbol(f15, Decl(a.ts, 17, 18)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f15 : Symbol(f15, Decl(a.ts, 16, 18)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f16(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f16 : Symbol(f16, Decl(a.ts, 18, 36)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f16 : Symbol(f16, Decl(a.ts, 17, 36)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f17(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f17 : Symbol(f17, Decl(a.ts, 19, 42)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f17 : Symbol(f17, Decl(a.ts, 18, 42)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f18(a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f18 : Symbol(f18, Decl(a.ts, 20, 54)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f18 : Symbol(f18, Decl(a.ts, 19, 54)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) var a = f19(a, a); ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->f19 : Symbol(f19, Decl(a.ts, 21, 67)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) ->a : Symbol(a, Decl(a.ts, 1, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>f19 : Symbol(f19, Decl(a.ts, 20, 67)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) +>a : Symbol(a, Decl(a.ts, 0, 3), Decl(a.js, 0, 3), Decl(a.js, 1, 3), Decl(a.js, 3, 3), Decl(a.js, 4, 3), Decl(a.js, 5, 3), Decl(a.js, 6, 3), Decl(a.js, 7, 3), Decl(a.js, 8, 3), Decl(a.js, 9, 3), Decl(a.js, 10, 3), Decl(a.js, 14, 3), Decl(a.js, 15, 3), Decl(a.js, 16, 3), Decl(a.js, 17, 3), Decl(a.js, 18, 3)) diff --git a/tests/baselines/reference/inferingFromAny.types b/tests/baselines/reference/inferingFromAny.types index c991f12f45cfd..72e2024d0224e 100644 --- a/tests/baselines/reference/inferingFromAny.types +++ b/tests/baselines/reference/inferingFromAny.types @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/a.ts === - var a: any; >a : any diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js index 2993a331fee3f..ba528d4c133eb 100644 --- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js +++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js @@ -1,5 +1,4 @@ //// [inferredFunctionReturnTypeIsEmptyType.ts] - function foo() { if (true) { return 42; diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.symbols b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.symbols index 059a992c3f33d..8fdfe5233e75a 100644 --- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.symbols +++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts === - function foo() { >foo : Symbol(foo, Decl(inferredFunctionReturnTypeIsEmptyType.ts, 0, 0)) diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types index 3775ffd2faa82..ba643dc3d624a 100644 --- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types +++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts === - function foo() { >foo : () => 42 | "42" diff --git a/tests/baselines/reference/inferringClassMembersFromAssignments.js b/tests/baselines/reference/inferringClassMembersFromAssignments.js index 74c47dab5657c..1c1f223abe85d 100644 --- a/tests/baselines/reference/inferringClassMembersFromAssignments.js +++ b/tests/baselines/reference/inferringClassMembersFromAssignments.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/salsa/inferringClassMembersFromAssignments.ts] //// //// [a.js] - class C { constructor() { if (Math.random()) { diff --git a/tests/baselines/reference/inferringClassMembersFromAssignments.symbols b/tests/baselines/reference/inferringClassMembersFromAssignments.symbols index 086c424669751..5e0efa182a9ec 100644 --- a/tests/baselines/reference/inferringClassMembersFromAssignments.symbols +++ b/tests/baselines/reference/inferringClassMembersFromAssignments.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/a.js === - class C { >C : Symbol(C, Decl(a.js, 0, 0)) @@ -10,23 +9,23 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inConstructor = 0; ->this.inConstructor : Symbol(C.inConstructor, Decl(a.js, 3, 28), Decl(a.js, 6, 14)) +>this.inConstructor : Symbol(C.inConstructor, Decl(a.js, 2, 28), Decl(a.js, 5, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inConstructor : Symbol(C.inConstructor, Decl(a.js, 3, 28), Decl(a.js, 6, 14)) +>inConstructor : Symbol(C.inConstructor, Decl(a.js, 2, 28), Decl(a.js, 5, 14)) } else { this.inConstructor = "string" ->this.inConstructor : Symbol(C.inConstructor, Decl(a.js, 3, 28), Decl(a.js, 6, 14)) +>this.inConstructor : Symbol(C.inConstructor, Decl(a.js, 2, 28), Decl(a.js, 5, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inConstructor : Symbol(C.inConstructor, Decl(a.js, 3, 28), Decl(a.js, 6, 14)) +>inConstructor : Symbol(C.inConstructor, Decl(a.js, 2, 28), Decl(a.js, 5, 14)) } this.inMultiple = 0; ->this.inMultiple : Symbol(C.inMultiple, Decl(a.js, 8, 9), Decl(a.js, 17, 9), Decl(a.js, 35, 9)) +>this.inMultiple : Symbol(C.inMultiple, Decl(a.js, 7, 9), Decl(a.js, 16, 9), Decl(a.js, 34, 9)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inMultiple : Symbol(C.inMultiple, Decl(a.js, 8, 9), Decl(a.js, 17, 9), Decl(a.js, 35, 9)) +>inMultiple : Symbol(C.inMultiple, Decl(a.js, 7, 9), Decl(a.js, 16, 9), Decl(a.js, 34, 9)) } method() { ->method : Symbol(C.method, Decl(a.js, 10, 5)) +>method : Symbol(C.method, Decl(a.js, 9, 5)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -34,23 +33,23 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inMethod = 0; ->this.inMethod : Symbol(C.inMethod, Decl(a.js, 12, 28), Decl(a.js, 15, 14)) +>this.inMethod : Symbol(C.inMethod, Decl(a.js, 11, 28), Decl(a.js, 14, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inMethod : Symbol(C.inMethod, Decl(a.js, 12, 28), Decl(a.js, 15, 14)) +>inMethod : Symbol(C.inMethod, Decl(a.js, 11, 28), Decl(a.js, 14, 14)) } else { this.inMethod = "string" ->this.inMethod : Symbol(C.inMethod, Decl(a.js, 12, 28), Decl(a.js, 15, 14)) +>this.inMethod : Symbol(C.inMethod, Decl(a.js, 11, 28), Decl(a.js, 14, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inMethod : Symbol(C.inMethod, Decl(a.js, 12, 28), Decl(a.js, 15, 14)) +>inMethod : Symbol(C.inMethod, Decl(a.js, 11, 28), Decl(a.js, 14, 14)) } this.inMultiple = "string"; ->this.inMultiple : Symbol(C.inMultiple, Decl(a.js, 8, 9), Decl(a.js, 17, 9), Decl(a.js, 35, 9)) +>this.inMultiple : Symbol(C.inMultiple, Decl(a.js, 7, 9), Decl(a.js, 16, 9), Decl(a.js, 34, 9)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inMultiple : Symbol(C.inMultiple, Decl(a.js, 8, 9), Decl(a.js, 17, 9), Decl(a.js, 35, 9)) +>inMultiple : Symbol(C.inMultiple, Decl(a.js, 7, 9), Decl(a.js, 16, 9), Decl(a.js, 34, 9)) var action = () => { ->action : Symbol(action, Decl(a.js, 20, 11)) +>action : Symbol(action, Decl(a.js, 19, 11)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -58,20 +57,20 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inNestedArrowFunction = 0; ->this.inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 21, 32), Decl(a.js, 24, 18)) +>this.inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 20, 32), Decl(a.js, 23, 18)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 21, 32), Decl(a.js, 24, 18)) +>inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 20, 32), Decl(a.js, 23, 18)) } else { this.inNestedArrowFunction = "string" ->this.inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 21, 32), Decl(a.js, 24, 18)) +>this.inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 20, 32), Decl(a.js, 23, 18)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 21, 32), Decl(a.js, 24, 18)) +>inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 20, 32), Decl(a.js, 23, 18)) } }; } get() { ->get : Symbol(C.get, Decl(a.js, 28, 5)) +>get : Symbol(C.get, Decl(a.js, 27, 5)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -79,23 +78,23 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inGetter = 0; ->this.inGetter : Symbol(C.inGetter, Decl(a.js, 30, 28), Decl(a.js, 33, 14)) +>this.inGetter : Symbol(C.inGetter, Decl(a.js, 29, 28), Decl(a.js, 32, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inGetter : Symbol(C.inGetter, Decl(a.js, 30, 28), Decl(a.js, 33, 14)) +>inGetter : Symbol(C.inGetter, Decl(a.js, 29, 28), Decl(a.js, 32, 14)) } else { this.inGetter = "string" ->this.inGetter : Symbol(C.inGetter, Decl(a.js, 30, 28), Decl(a.js, 33, 14)) +>this.inGetter : Symbol(C.inGetter, Decl(a.js, 29, 28), Decl(a.js, 32, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inGetter : Symbol(C.inGetter, Decl(a.js, 30, 28), Decl(a.js, 33, 14)) +>inGetter : Symbol(C.inGetter, Decl(a.js, 29, 28), Decl(a.js, 32, 14)) } this.inMultiple = false; ->this.inMultiple : Symbol(C.inMultiple, Decl(a.js, 8, 9), Decl(a.js, 17, 9), Decl(a.js, 35, 9)) +>this.inMultiple : Symbol(C.inMultiple, Decl(a.js, 7, 9), Decl(a.js, 16, 9), Decl(a.js, 34, 9)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inMultiple : Symbol(C.inMultiple, Decl(a.js, 8, 9), Decl(a.js, 17, 9), Decl(a.js, 35, 9)) +>inMultiple : Symbol(C.inMultiple, Decl(a.js, 7, 9), Decl(a.js, 16, 9), Decl(a.js, 34, 9)) } set() { ->set : Symbol(C.set, Decl(a.js, 37, 5)) +>set : Symbol(C.set, Decl(a.js, 36, 5)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -103,19 +102,19 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inSetter = 0; ->this.inSetter : Symbol(C.inSetter, Decl(a.js, 39, 28), Decl(a.js, 42, 14)) +>this.inSetter : Symbol(C.inSetter, Decl(a.js, 38, 28), Decl(a.js, 41, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inSetter : Symbol(C.inSetter, Decl(a.js, 39, 28), Decl(a.js, 42, 14)) +>inSetter : Symbol(C.inSetter, Decl(a.js, 38, 28), Decl(a.js, 41, 14)) } else { this.inSetter = "string" ->this.inSetter : Symbol(C.inSetter, Decl(a.js, 39, 28), Decl(a.js, 42, 14)) +>this.inSetter : Symbol(C.inSetter, Decl(a.js, 38, 28), Decl(a.js, 41, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inSetter : Symbol(C.inSetter, Decl(a.js, 39, 28), Decl(a.js, 42, 14)) +>inSetter : Symbol(C.inSetter, Decl(a.js, 38, 28), Decl(a.js, 41, 14)) } } prop = () => { ->prop : Symbol(C.prop, Decl(a.js, 45, 5)) +>prop : Symbol(C.prop, Decl(a.js, 44, 5)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -123,19 +122,19 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inPropertyDeclaration = 0; ->this.inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 47, 28), Decl(a.js, 50, 14)) +>this.inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 46, 28), Decl(a.js, 49, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 47, 28), Decl(a.js, 50, 14)) +>inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 46, 28), Decl(a.js, 49, 14)) } else { this.inPropertyDeclaration = "string" ->this.inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 47, 28), Decl(a.js, 50, 14)) +>this.inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 46, 28), Decl(a.js, 49, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 47, 28), Decl(a.js, 50, 14)) +>inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 46, 28), Decl(a.js, 49, 14)) } } static method() { ->method : Symbol(C.method, Decl(a.js, 53, 5)) +>method : Symbol(C.method, Decl(a.js, 52, 5)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -143,19 +142,19 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inStaticMethod = 0; ->this.inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 55, 28), Decl(a.js, 58, 14)) +>this.inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 54, 28), Decl(a.js, 57, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 55, 28), Decl(a.js, 58, 14)) +>inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 54, 28), Decl(a.js, 57, 14)) } else { this.inStaticMethod = "string" ->this.inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 55, 28), Decl(a.js, 58, 14)) +>this.inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 54, 28), Decl(a.js, 57, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 55, 28), Decl(a.js, 58, 14)) +>inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 54, 28), Decl(a.js, 57, 14)) } var action = () => { ->action : Symbol(action, Decl(a.js, 62, 11)) +>action : Symbol(action, Decl(a.js, 61, 11)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -163,20 +162,20 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inStaticNestedArrowFunction = 0; ->this.inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 63, 32), Decl(a.js, 66, 18)) +>this.inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 62, 32), Decl(a.js, 65, 18)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 63, 32), Decl(a.js, 66, 18)) +>inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 62, 32), Decl(a.js, 65, 18)) } else { this.inStaticNestedArrowFunction = "string" ->this.inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 63, 32), Decl(a.js, 66, 18)) +>this.inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 62, 32), Decl(a.js, 65, 18)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 63, 32), Decl(a.js, 66, 18)) +>inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 62, 32), Decl(a.js, 65, 18)) } }; } static get() { ->get : Symbol(C.get, Decl(a.js, 70, 5)) +>get : Symbol(C.get, Decl(a.js, 69, 5)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -184,19 +183,19 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inStaticGetter = 0; ->this.inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 72, 28), Decl(a.js, 75, 14)) +>this.inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 71, 28), Decl(a.js, 74, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 72, 28), Decl(a.js, 75, 14)) +>inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 71, 28), Decl(a.js, 74, 14)) } else { this.inStaticGetter = "string" ->this.inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 72, 28), Decl(a.js, 75, 14)) +>this.inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 71, 28), Decl(a.js, 74, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 72, 28), Decl(a.js, 75, 14)) +>inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 71, 28), Decl(a.js, 74, 14)) } } static set() { ->set : Symbol(C.set, Decl(a.js, 78, 5)) +>set : Symbol(C.set, Decl(a.js, 77, 5)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -204,19 +203,19 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inStaticSetter = 0; ->this.inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 80, 28), Decl(a.js, 83, 14)) +>this.inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 79, 28), Decl(a.js, 82, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 80, 28), Decl(a.js, 83, 14)) +>inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 79, 28), Decl(a.js, 82, 14)) } else { this.inStaticSetter = "string" ->this.inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 80, 28), Decl(a.js, 83, 14)) +>this.inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 79, 28), Decl(a.js, 82, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 80, 28), Decl(a.js, 83, 14)) +>inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 79, 28), Decl(a.js, 82, 14)) } } static prop = () => { ->prop : Symbol(C.prop, Decl(a.js, 86, 5)) +>prop : Symbol(C.prop, Decl(a.js, 85, 5)) if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) @@ -224,15 +223,15 @@ class C { >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) this.inStaticPropertyDeclaration = 0; ->this.inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 88, 28), Decl(a.js, 91, 14)) +>this.inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 87, 28), Decl(a.js, 90, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 88, 28), Decl(a.js, 91, 14)) +>inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 87, 28), Decl(a.js, 90, 14)) } else { this.inStaticPropertyDeclaration = "string" ->this.inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 88, 28), Decl(a.js, 91, 14)) +>this.inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 87, 28), Decl(a.js, 90, 14)) >this : Symbol(C, Decl(a.js, 0, 0)) ->inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 88, 28), Decl(a.js, 91, 14)) +>inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 87, 28), Decl(a.js, 90, 14)) } } } @@ -247,80 +246,80 @@ var stringOrNumber: string | number; var stringOrNumber = c.inConstructor; >stringOrNumber : Symbol(stringOrNumber, Decl(b.ts, 2, 3), Decl(b.ts, 3, 3)) ->c.inConstructor : Symbol(C.inConstructor, Decl(a.js, 3, 28), Decl(a.js, 6, 14)) +>c.inConstructor : Symbol(C.inConstructor, Decl(a.js, 2, 28), Decl(a.js, 5, 14)) >c : Symbol(c, Decl(b.ts, 0, 3)) ->inConstructor : Symbol(C.inConstructor, Decl(a.js, 3, 28), Decl(a.js, 6, 14)) +>inConstructor : Symbol(C.inConstructor, Decl(a.js, 2, 28), Decl(a.js, 5, 14)) var stringOrNumberOrUndefined: string | number | undefined; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) var stringOrNumberOrUndefined = c.inMethod; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->c.inMethod : Symbol(C.inMethod, Decl(a.js, 12, 28), Decl(a.js, 15, 14)) +>c.inMethod : Symbol(C.inMethod, Decl(a.js, 11, 28), Decl(a.js, 14, 14)) >c : Symbol(c, Decl(b.ts, 0, 3)) ->inMethod : Symbol(C.inMethod, Decl(a.js, 12, 28), Decl(a.js, 15, 14)) +>inMethod : Symbol(C.inMethod, Decl(a.js, 11, 28), Decl(a.js, 14, 14)) var stringOrNumberOrUndefined = c.inGetter; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->c.inGetter : Symbol(C.inGetter, Decl(a.js, 30, 28), Decl(a.js, 33, 14)) +>c.inGetter : Symbol(C.inGetter, Decl(a.js, 29, 28), Decl(a.js, 32, 14)) >c : Symbol(c, Decl(b.ts, 0, 3)) ->inGetter : Symbol(C.inGetter, Decl(a.js, 30, 28), Decl(a.js, 33, 14)) +>inGetter : Symbol(C.inGetter, Decl(a.js, 29, 28), Decl(a.js, 32, 14)) var stringOrNumberOrUndefined = c.inSetter; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->c.inSetter : Symbol(C.inSetter, Decl(a.js, 39, 28), Decl(a.js, 42, 14)) +>c.inSetter : Symbol(C.inSetter, Decl(a.js, 38, 28), Decl(a.js, 41, 14)) >c : Symbol(c, Decl(b.ts, 0, 3)) ->inSetter : Symbol(C.inSetter, Decl(a.js, 39, 28), Decl(a.js, 42, 14)) +>inSetter : Symbol(C.inSetter, Decl(a.js, 38, 28), Decl(a.js, 41, 14)) var stringOrNumberOrUndefined = c.inPropertyDeclaration; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->c.inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 47, 28), Decl(a.js, 50, 14)) +>c.inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 46, 28), Decl(a.js, 49, 14)) >c : Symbol(c, Decl(b.ts, 0, 3)) ->inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 47, 28), Decl(a.js, 50, 14)) +>inPropertyDeclaration : Symbol(C.inPropertyDeclaration, Decl(a.js, 46, 28), Decl(a.js, 49, 14)) var stringOrNumberOrUndefined = c.inNestedArrowFunction >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->c.inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 21, 32), Decl(a.js, 24, 18)) +>c.inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 20, 32), Decl(a.js, 23, 18)) >c : Symbol(c, Decl(b.ts, 0, 3)) ->inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 21, 32), Decl(a.js, 24, 18)) +>inNestedArrowFunction : Symbol(C.inNestedArrowFunction, Decl(a.js, 20, 32), Decl(a.js, 23, 18)) var stringOrNumberOrBoolean: string | number | boolean; >stringOrNumberOrBoolean : Symbol(stringOrNumberOrBoolean, Decl(b.ts, 13, 3), Decl(b.ts, 15, 3)) var stringOrNumberOrBoolean = c.inMultiple; >stringOrNumberOrBoolean : Symbol(stringOrNumberOrBoolean, Decl(b.ts, 13, 3), Decl(b.ts, 15, 3)) ->c.inMultiple : Symbol(C.inMultiple, Decl(a.js, 8, 9), Decl(a.js, 17, 9), Decl(a.js, 35, 9)) +>c.inMultiple : Symbol(C.inMultiple, Decl(a.js, 7, 9), Decl(a.js, 16, 9), Decl(a.js, 34, 9)) >c : Symbol(c, Decl(b.ts, 0, 3)) ->inMultiple : Symbol(C.inMultiple, Decl(a.js, 8, 9), Decl(a.js, 17, 9), Decl(a.js, 35, 9)) +>inMultiple : Symbol(C.inMultiple, Decl(a.js, 7, 9), Decl(a.js, 16, 9), Decl(a.js, 34, 9)) var stringOrNumberOrUndefined = C.inStaticMethod; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->C.inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 55, 28), Decl(a.js, 58, 14)) +>C.inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 54, 28), Decl(a.js, 57, 14)) >C : Symbol(C, Decl(a.js, 0, 0)) ->inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 55, 28), Decl(a.js, 58, 14)) +>inStaticMethod : Symbol(C.inStaticMethod, Decl(a.js, 54, 28), Decl(a.js, 57, 14)) var stringOrNumberOrUndefined = C.inStaticGetter; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->C.inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 72, 28), Decl(a.js, 75, 14)) +>C.inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 71, 28), Decl(a.js, 74, 14)) >C : Symbol(C, Decl(a.js, 0, 0)) ->inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 72, 28), Decl(a.js, 75, 14)) +>inStaticGetter : Symbol(C.inStaticGetter, Decl(a.js, 71, 28), Decl(a.js, 74, 14)) var stringOrNumberOrUndefined = C.inStaticSetter; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->C.inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 80, 28), Decl(a.js, 83, 14)) +>C.inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 79, 28), Decl(a.js, 82, 14)) >C : Symbol(C, Decl(a.js, 0, 0)) ->inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 80, 28), Decl(a.js, 83, 14)) +>inStaticSetter : Symbol(C.inStaticSetter, Decl(a.js, 79, 28), Decl(a.js, 82, 14)) var stringOrNumberOrUndefined = C.inStaticPropertyDeclaration; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->C.inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 88, 28), Decl(a.js, 91, 14)) +>C.inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 87, 28), Decl(a.js, 90, 14)) >C : Symbol(C, Decl(a.js, 0, 0)) ->inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 88, 28), Decl(a.js, 91, 14)) +>inStaticPropertyDeclaration : Symbol(C.inStaticPropertyDeclaration, Decl(a.js, 87, 28), Decl(a.js, 90, 14)) var stringOrNumberOrUndefined = C.inStaticNestedArrowFunction; >stringOrNumberOrUndefined : Symbol(stringOrNumberOrUndefined, Decl(b.ts, 5, 3), Decl(b.ts, 7, 3), Decl(b.ts, 8, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 18, 3), Decl(b.ts, 19, 3), Decl(b.ts, 20, 3), Decl(b.ts, 21, 3), Decl(b.ts, 22, 3)) ->C.inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 63, 32), Decl(a.js, 66, 18)) +>C.inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 62, 32), Decl(a.js, 65, 18)) >C : Symbol(C, Decl(a.js, 0, 0)) ->inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 63, 32), Decl(a.js, 66, 18)) +>inStaticNestedArrowFunction : Symbol(C.inStaticNestedArrowFunction, Decl(a.js, 62, 32), Decl(a.js, 65, 18)) diff --git a/tests/baselines/reference/inferringClassMembersFromAssignments.types b/tests/baselines/reference/inferringClassMembersFromAssignments.types index d759009983c0c..e462a04d198a0 100644 --- a/tests/baselines/reference/inferringClassMembersFromAssignments.types +++ b/tests/baselines/reference/inferringClassMembersFromAssignments.types @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/a.js === - class C { >C : C diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt index 787b95f22976d..08aab5b1158c5 100644 --- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt +++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(6,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(5,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ==== tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts (2 errors) ==== - class a { static get x(): () => string { ~ diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js index 79d2e88b64681..3c19e3c5f67e1 100644 --- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js +++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js @@ -1,5 +1,4 @@ //// [inheritanceStaticPropertyOverridingAccessor.ts] - class a { static get x(): () => string { return null;; diff --git a/tests/baselines/reference/inheritedGenericCallSignature.js b/tests/baselines/reference/inheritedGenericCallSignature.js index 2ee6e2149a9ef..2f28498fc8c25 100644 --- a/tests/baselines/reference/inheritedGenericCallSignature.js +++ b/tests/baselines/reference/inheritedGenericCallSignature.js @@ -1,5 +1,4 @@ //// [inheritedGenericCallSignature.ts] - interface I1 { (a: T): T; diff --git a/tests/baselines/reference/inheritedGenericCallSignature.symbols b/tests/baselines/reference/inheritedGenericCallSignature.symbols index 57469f4dad820..715393e6a31fc 100644 --- a/tests/baselines/reference/inheritedGenericCallSignature.symbols +++ b/tests/baselines/reference/inheritedGenericCallSignature.symbols @@ -1,50 +1,49 @@ === tests/cases/compiler/inheritedGenericCallSignature.ts === - interface I1 { >I1 : Symbol(I1, Decl(inheritedGenericCallSignature.ts, 0, 0)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 1, 13)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 0, 13)) (a: T): T; ->a : Symbol(a, Decl(inheritedGenericCallSignature.ts, 3, 5)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 1, 13)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 1, 13)) +>a : Symbol(a, Decl(inheritedGenericCallSignature.ts, 2, 5)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 0, 13)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 0, 13)) } interface Object {} ->Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(inheritedGenericCallSignature.ts, 5, 1)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(inheritedGenericCallSignature.ts, 4, 1)) interface I2 extends I1 { ->I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 8, 19)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 12, 13)) +>I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 7, 19)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 11, 13)) >I1 : Symbol(I1, Decl(inheritedGenericCallSignature.ts, 0, 0)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 12, 13)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 11, 13)) b: T; ->b : Symbol(I2.b, Decl(inheritedGenericCallSignature.ts, 12, 33)) ->T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 12, 13)) +>b : Symbol(I2.b, Decl(inheritedGenericCallSignature.ts, 11, 33)) +>T : Symbol(T, Decl(inheritedGenericCallSignature.ts, 11, 13)) } var x: I2; ->x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 20, 3)) ->I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 8, 19)) +>x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 19, 3)) +>I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 7, 19)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var y = x(undefined); ->y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 24, 3)) ->x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 20, 3)) +>y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 23, 3)) +>x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 19, 3)) >undefined : Symbol(undefined) y.length; // should not error >y.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 24, 3)) +>y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 23, 3)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/inheritedGenericCallSignature.types b/tests/baselines/reference/inheritedGenericCallSignature.types index 4382320862b12..ca881df6c5dbd 100644 --- a/tests/baselines/reference/inheritedGenericCallSignature.types +++ b/tests/baselines/reference/inheritedGenericCallSignature.types @@ -1,5 +1,4 @@ === tests/cases/compiler/inheritedGenericCallSignature.ts === - interface I1 { >I1 : I1 >T : T diff --git a/tests/baselines/reference/initializePropertiesWithRenamedLet.js b/tests/baselines/reference/initializePropertiesWithRenamedLet.js index 4abe488aa0899..d6c53b7d5252b 100644 --- a/tests/baselines/reference/initializePropertiesWithRenamedLet.js +++ b/tests/baselines/reference/initializePropertiesWithRenamedLet.js @@ -1,5 +1,4 @@ //// [initializePropertiesWithRenamedLet.ts] - var x0; if (true) { let x0; diff --git a/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols b/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols index f16d8cfc9e039..02abf8c80e08d 100644 --- a/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols +++ b/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols @@ -1,46 +1,45 @@ === tests/cases/compiler/initializePropertiesWithRenamedLet.ts === - var x0; ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 1, 3)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 0, 3)) if (true) { let x0; ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 3, 7)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 2, 7)) var obj1 = { x0: x0 }; ->obj1 : Symbol(obj1, Decl(initializePropertiesWithRenamedLet.ts, 4, 7)) ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 4, 16)) ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 3, 7)) +>obj1 : Symbol(obj1, Decl(initializePropertiesWithRenamedLet.ts, 3, 7)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 3, 16)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 2, 7)) var obj2 = { x0 }; ->obj2 : Symbol(obj2, Decl(initializePropertiesWithRenamedLet.ts, 5, 7)) ->x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 5, 16)) +>obj2 : Symbol(obj2, Decl(initializePropertiesWithRenamedLet.ts, 4, 7)) +>x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 4, 16)) } var x, y, z; ->x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 8, 3)) ->y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 8, 6)) ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 8, 9)) +>x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 7, 3)) +>y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 7, 6)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 7, 9)) if (true) { let { x: x } = { x: 0 }; ->x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 20)) ->x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 9)) ->x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 20)) +>x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 9, 20)) +>x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 9, 9)) +>x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 9, 20)) let { y } = { y: 0 }; ->y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 11, 9)) ->y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 11, 17)) +>y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 10, 9)) +>y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 10, 17)) let z; ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 7)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 11, 7)) ({ z: z } = { z: 0 }); ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 6)) ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 7)) ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 17)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 6)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 11, 7)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 17)) ({ z } = { z: 0 }); ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 14, 6)) ->z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 14, 14)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 6)) +>z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 14)) } diff --git a/tests/baselines/reference/initializePropertiesWithRenamedLet.types b/tests/baselines/reference/initializePropertiesWithRenamedLet.types index 65ea68059a7b9..cfcf1957125e6 100644 --- a/tests/baselines/reference/initializePropertiesWithRenamedLet.types +++ b/tests/baselines/reference/initializePropertiesWithRenamedLet.types @@ -1,5 +1,4 @@ === tests/cases/compiler/initializePropertiesWithRenamedLet.ts === - var x0; >x0 : any diff --git a/tests/baselines/reference/initializersInDeclarations.errors.txt b/tests/baselines/reference/initializersInDeclarations.errors.txt index c8b307cb21cd6..34a7b67e5d59c 100644 --- a/tests/baselines/reference/initializersInDeclarations.errors.txt +++ b/tests/baselines/reference/initializersInDeclarations.errors.txt @@ -1,14 +1,13 @@ -tests/cases/conformance/externalModules/file1.d.ts(5,9): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(6,16): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(7,16): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(4,9): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(5,16): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(6,16): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(11,15): error TS1039: Initializers are not allowed in ambient contexts. tests/cases/conformance/externalModules/file1.d.ts(12,15): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(13,15): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(16,2): error TS1036: Statements are not allowed in ambient contexts. -tests/cases/conformance/externalModules/file1.d.ts(18,16): error TS1039: Initializers are not allowed in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(15,2): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/conformance/externalModules/file1.d.ts(17,16): error TS1039: Initializers are not allowed in ambient contexts. ==== tests/cases/conformance/externalModules/file1.d.ts (7 errors) ==== - // Errors: Initializers & statements in declaration file declare class Foo { diff --git a/tests/baselines/reference/inlineSourceMap.errors.txt b/tests/baselines/reference/inlineSourceMap.errors.txt index 8d92d6a161d3e..69ea738f6bd5b 100644 --- a/tests/baselines/reference/inlineSourceMap.errors.txt +++ b/tests/baselines/reference/inlineSourceMap.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/inlineSourceMap.ts(3,1): error TS2304: Cannot find name 'console'. +tests/cases/compiler/inlineSourceMap.ts(2,1): error TS2304: Cannot find name 'console'. ==== tests/cases/compiler/inlineSourceMap.ts (1 errors) ==== - var x = 0; console.log(x); ~~~~~~~ diff --git a/tests/baselines/reference/inlineSourceMap.js b/tests/baselines/reference/inlineSourceMap.js index 94ad43d448730..2bc68adc516a1 100644 --- a/tests/baselines/reference/inlineSourceMap.js +++ b/tests/baselines/reference/inlineSourceMap.js @@ -1,9 +1,8 @@ //// [inlineSourceMap.ts] - var x = 0; console.log(x); //// [inlineSourceMap.js] var x = 0; console.log(x); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSourceMap.sourcemap.txt b/tests/baselines/reference/inlineSourceMap.sourcemap.txt index 35bee4f1d4a95..7967c04e90517 100644 --- a/tests/baselines/reference/inlineSourceMap.sourcemap.txt +++ b/tests/baselines/reference/inlineSourceMap.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: inlineSourceMap.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== sourceRoot: sources: inlineSourceMap.ts =================================================================== @@ -16,19 +16,18 @@ sourceFile:inlineSourceMap.ts 5 > ^ 6 > ^ 7 > ^^^^^^-> -1 > - > +1 > 2 >var 3 > x 4 > = 5 > 0 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(1, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) --- >>>console.log(x); 1-> @@ -49,13 +48,13 @@ sourceFile:inlineSourceMap.ts 6 > x 7 > ) 8 > ; -1->Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 8) Source(3, 8) + SourceIndex(0) -3 >Emitted(2, 9) Source(3, 9) + SourceIndex(0) -4 >Emitted(2, 12) Source(3, 12) + SourceIndex(0) -5 >Emitted(2, 13) Source(3, 13) + SourceIndex(0) -6 >Emitted(2, 14) Source(3, 14) + SourceIndex(0) -7 >Emitted(2, 15) Source(3, 15) + SourceIndex(0) -8 >Emitted(2, 16) Source(3, 16) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +3 >Emitted(2, 9) Source(2, 9) + SourceIndex(0) +4 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +5 >Emitted(2, 13) Source(2, 13) + SourceIndex(0) +6 >Emitted(2, 14) Source(2, 14) + SourceIndex(0) +7 >Emitted(2, 15) Source(2, 15) + SourceIndex(0) +8 >Emitted(2, 16) Source(2, 16) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW5saW5lU291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSourceMap2.errors.txt b/tests/baselines/reference/inlineSourceMap2.errors.txt index 26db1415593d0..ee60b349348c3 100644 --- a/tests/baselines/reference/inlineSourceMap2.errors.txt +++ b/tests/baselines/reference/inlineSourceMap2.errors.txt @@ -1,12 +1,11 @@ error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'. error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'. -tests/cases/compiler/inlineSourceMap2.ts(5,1): error TS2304: Cannot find name 'console'. +tests/cases/compiler/inlineSourceMap2.ts(4,1): error TS2304: Cannot find name 'console'. !!! error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'. !!! error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'. ==== tests/cases/compiler/inlineSourceMap2.ts (1 errors) ==== - // configuration errors var x = 0; diff --git a/tests/baselines/reference/inlineSourceMap2.js b/tests/baselines/reference/inlineSourceMap2.js index 9cf2786334660..ce39cfbbf6bfd 100644 --- a/tests/baselines/reference/inlineSourceMap2.js +++ b/tests/baselines/reference/inlineSourceMap2.js @@ -1,5 +1,4 @@ //// [inlineSourceMap2.ts] - // configuration errors var x = 0; @@ -9,4 +8,4 @@ console.log(x); // configuration errors var x = 0; console.log(x); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSourceMap2.sourcemap.txt b/tests/baselines/reference/inlineSourceMap2.sourcemap.txt index e292a9b96b2a4..5407acb05fd64 100644 --- a/tests/baselines/reference/inlineSourceMap2.sourcemap.txt +++ b/tests/baselines/reference/inlineSourceMap2.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: outfile.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== sourceRoot: file:///folder/ sources: inlineSourceMap2.ts =================================================================== @@ -11,11 +11,10 @@ sourceFile:inlineSourceMap2.ts >>>// configuration errors 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^ -1 > - > +1 > 2 >// configuration errors -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 24) Source(2, 24) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 24) Source(1, 24) + SourceIndex(0) --- >>>var x = 0; 1 > @@ -33,12 +32,12 @@ sourceFile:inlineSourceMap2.ts 4 > = 5 > 0 6 > ; -1 >Emitted(2, 1) Source(4, 1) + SourceIndex(0) -2 >Emitted(2, 5) Source(4, 5) + SourceIndex(0) -3 >Emitted(2, 6) Source(4, 6) + SourceIndex(0) -4 >Emitted(2, 9) Source(4, 9) + SourceIndex(0) -5 >Emitted(2, 10) Source(4, 10) + SourceIndex(0) -6 >Emitted(2, 11) Source(4, 11) + SourceIndex(0) +1 >Emitted(2, 1) Source(3, 1) + SourceIndex(0) +2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) +3 >Emitted(2, 6) Source(3, 6) + SourceIndex(0) +4 >Emitted(2, 9) Source(3, 9) + SourceIndex(0) +5 >Emitted(2, 10) Source(3, 10) + SourceIndex(0) +6 >Emitted(2, 11) Source(3, 11) + SourceIndex(0) --- >>>console.log(x); 1-> @@ -59,13 +58,13 @@ sourceFile:inlineSourceMap2.ts 6 > x 7 > ) 8 > ; -1->Emitted(3, 1) Source(5, 1) + SourceIndex(0) -2 >Emitted(3, 8) Source(5, 8) + SourceIndex(0) -3 >Emitted(3, 9) Source(5, 9) + SourceIndex(0) -4 >Emitted(3, 12) Source(5, 12) + SourceIndex(0) -5 >Emitted(3, 13) Source(5, 13) + SourceIndex(0) -6 >Emitted(3, 14) Source(5, 14) + SourceIndex(0) -7 >Emitted(3, 15) Source(5, 15) + SourceIndex(0) -8 >Emitted(3, 16) Source(5, 16) + SourceIndex(0) +1->Emitted(3, 1) Source(4, 1) + SourceIndex(0) +2 >Emitted(3, 8) Source(4, 8) + SourceIndex(0) +3 >Emitted(3, 9) Source(4, 9) + SourceIndex(0) +4 >Emitted(3, 12) Source(4, 12) + SourceIndex(0) +5 >Emitted(3, 13) Source(4, 13) + SourceIndex(0) +6 >Emitted(3, 14) Source(4, 14) + SourceIndex(0) +7 >Emitted(3, 15) Source(4, 15) + SourceIndex(0) +8 >Emitted(3, 16) Source(4, 16) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0ZmlsZS5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsdUJBQXVCO0FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSources.errors.txt b/tests/baselines/reference/inlineSources.errors.txt index 1c86dcf4d993e..ff72c35b867f2 100644 --- a/tests/baselines/reference/inlineSources.errors.txt +++ b/tests/baselines/reference/inlineSources.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/a.ts(3,1): error TS2304: Cannot find name 'console'. +tests/cases/compiler/a.ts(2,1): error TS2304: Cannot find name 'console'. tests/cases/compiler/b.ts(2,1): error TS2304: Cannot find name 'console'. ==== tests/cases/compiler/a.ts (1 errors) ==== - var a = 0; console.log(a); ~~~~~~~ diff --git a/tests/baselines/reference/inlineSources.js b/tests/baselines/reference/inlineSources.js index c700af7e4c607..8ac6bf43bee02 100644 --- a/tests/baselines/reference/inlineSources.js +++ b/tests/baselines/reference/inlineSources.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/inlineSources.ts] //// //// [a.ts] - var a = 0; console.log(a); diff --git a/tests/baselines/reference/inlineSources.js.map b/tests/baselines/reference/inlineSources.js.map index 7e09d95a35c75..8ccdb8c32f772 100644 --- a/tests/baselines/reference/inlineSources.js.map +++ b/tests/baselines/reference/inlineSources.js.map @@ -1,2 +1,2 @@ //// [out.js.map] -{"version":3,"file":"out.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;ACFf,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC","sourcesContent":["\nvar a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"]} \ No newline at end of file +{"version":3,"file":"out.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;ACDf,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC","sourcesContent":["var a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"]} \ No newline at end of file diff --git a/tests/baselines/reference/inlineSources.sourcemap.txt b/tests/baselines/reference/inlineSources.sourcemap.txt index 47d762f044e6b..a6a55d0cb35c3 100644 --- a/tests/baselines/reference/inlineSources.sourcemap.txt +++ b/tests/baselines/reference/inlineSources.sourcemap.txt @@ -3,7 +3,7 @@ JsFile: out.js mapUrl: out.js.map sourceRoot: sources: tests/cases/compiler/a.ts,tests/cases/compiler/b.ts -sourcesContent: ["\nvar a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"] +sourcesContent: ["var a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"] =================================================================== ------------------------------------------------------------------- emittedFile:out.js @@ -17,19 +17,18 @@ sourceFile:tests/cases/compiler/a.ts 5 > ^ 6 > ^ 7 > ^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 0 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(1, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) --- >>>console.log(a); 1-> @@ -49,14 +48,14 @@ sourceFile:tests/cases/compiler/a.ts 6 > a 7 > ) 8 > ; -1->Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 8) Source(3, 8) + SourceIndex(0) -3 >Emitted(2, 9) Source(3, 9) + SourceIndex(0) -4 >Emitted(2, 12) Source(3, 12) + SourceIndex(0) -5 >Emitted(2, 13) Source(3, 13) + SourceIndex(0) -6 >Emitted(2, 14) Source(3, 14) + SourceIndex(0) -7 >Emitted(2, 15) Source(3, 15) + SourceIndex(0) -8 >Emitted(2, 16) Source(3, 16) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +3 >Emitted(2, 9) Source(2, 9) + SourceIndex(0) +4 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +5 >Emitted(2, 13) Source(2, 13) + SourceIndex(0) +6 >Emitted(2, 14) Source(2, 14) + SourceIndex(0) +7 >Emitted(2, 15) Source(2, 15) + SourceIndex(0) +8 >Emitted(2, 16) Source(2, 16) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:out.js diff --git a/tests/baselines/reference/inlineSources2.errors.txt b/tests/baselines/reference/inlineSources2.errors.txt index 1c86dcf4d993e..ff72c35b867f2 100644 --- a/tests/baselines/reference/inlineSources2.errors.txt +++ b/tests/baselines/reference/inlineSources2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/a.ts(3,1): error TS2304: Cannot find name 'console'. +tests/cases/compiler/a.ts(2,1): error TS2304: Cannot find name 'console'. tests/cases/compiler/b.ts(2,1): error TS2304: Cannot find name 'console'. ==== tests/cases/compiler/a.ts (1 errors) ==== - var a = 0; console.log(a); ~~~~~~~ diff --git a/tests/baselines/reference/inlineSources2.js b/tests/baselines/reference/inlineSources2.js index 7f4c82f2ac290..e5909c5769ec2 100644 --- a/tests/baselines/reference/inlineSources2.js +++ b/tests/baselines/reference/inlineSources2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/inlineSources2.ts] //// //// [a.ts] - var a = 0; console.log(a); @@ -14,4 +13,4 @@ var a = 0; console.log(a); var b = 0; console.log(b); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0ZmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcbnZhciBhID0gMDtcbmNvbnNvbGUubG9nKGEpO1xuIiwidmFyIGIgPSAwO1xuY29uc29sZS5sb2coYik7Il19 \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0RmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgYSA9IDA7XG5jb25zb2xlLmxvZyhhKTtcbiIsInZhciBiID0gMDtcbmNvbnNvbGUubG9nKGIpOyJdfQ== \ No newline at end of file diff --git a/tests/baselines/reference/inlineSources2.sourcemap.txt b/tests/baselines/reference/inlineSources2.sourcemap.txt index e09af2f4221b6..0ce95f4de4db7 100644 --- a/tests/baselines/reference/inlineSources2.sourcemap.txt +++ b/tests/baselines/reference/inlineSources2.sourcemap.txt @@ -1,9 +1,9 @@ =================================================================== JsFile: out.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0ZmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcbnZhciBhID0gMDtcbmNvbnNvbGUubG9nKGEpO1xuIiwidmFyIGIgPSAwO1xuY29uc29sZS5sb2coYik7Il19 +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0RmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgYSA9IDA7XG5jb25zb2xlLmxvZyhhKTtcbiIsInZhciBiID0gMDtcbmNvbnNvbGUubG9nKGIpOyJdfQ== sourceRoot: sources: tests/cases/compiler/a.ts,tests/cases/compiler/b.ts -sourcesContent: ["\nvar a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"] +sourcesContent: ["var a = 0;\nconsole.log(a);\n","var b = 0;\nconsole.log(b);"] =================================================================== ------------------------------------------------------------------- emittedFile:out.js @@ -17,19 +17,18 @@ sourceFile:tests/cases/compiler/a.ts 5 > ^ 6 > ^ 7 > ^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 0 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(1, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) --- >>>console.log(a); 1-> @@ -49,14 +48,14 @@ sourceFile:tests/cases/compiler/a.ts 6 > a 7 > ) 8 > ; -1->Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 8) Source(3, 8) + SourceIndex(0) -3 >Emitted(2, 9) Source(3, 9) + SourceIndex(0) -4 >Emitted(2, 12) Source(3, 12) + SourceIndex(0) -5 >Emitted(2, 13) Source(3, 13) + SourceIndex(0) -6 >Emitted(2, 14) Source(3, 14) + SourceIndex(0) -7 >Emitted(2, 15) Source(3, 15) + SourceIndex(0) -8 >Emitted(2, 16) Source(3, 16) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +3 >Emitted(2, 9) Source(2, 9) + SourceIndex(0) +4 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +5 >Emitted(2, 13) Source(2, 13) + SourceIndex(0) +6 >Emitted(2, 14) Source(2, 14) + SourceIndex(0) +7 >Emitted(2, 15) Source(2, 15) + SourceIndex(0) +8 >Emitted(2, 16) Source(2, 16) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:out.js @@ -111,4 +110,4 @@ sourceFile:tests/cases/compiler/b.ts 7 >Emitted(4, 15) Source(2, 15) + SourceIndex(1) 8 >Emitted(4, 16) Source(2, 16) + SourceIndex(1) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0ZmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcbnZhciBhID0gMDtcbmNvbnNvbGUubG9nKGEpO1xuIiwidmFyIGIgPSAwO1xuY29uc29sZS5sb2coYik7Il19 \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdHMvY2FzZXMvY29tcGlsZXIvYS50cyIsInRlc3RzL2Nhc2VzL2NvbXBpbGVyL2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQ0RmLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNWLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgYSA9IDA7XG5jb25zb2xlLmxvZyhhKTtcbiIsInZhciBiID0gMDtcbmNvbnNvbGUubG9nKGIpOyJdfQ== \ No newline at end of file diff --git a/tests/baselines/reference/innerOverloads.js b/tests/baselines/reference/innerOverloads.js index 19e3fa78909c0..b761601169427 100644 --- a/tests/baselines/reference/innerOverloads.js +++ b/tests/baselines/reference/innerOverloads.js @@ -1,5 +1,4 @@ //// [innerOverloads.ts] - function outer() { function inner(x:number); // should work function inner(x:string); diff --git a/tests/baselines/reference/innerOverloads.symbols b/tests/baselines/reference/innerOverloads.symbols index d87a60b26e82d..5d9aaffc8f008 100644 --- a/tests/baselines/reference/innerOverloads.symbols +++ b/tests/baselines/reference/innerOverloads.symbols @@ -1,27 +1,26 @@ === tests/cases/compiler/innerOverloads.ts === - function outer() { >outer : Symbol(outer, Decl(innerOverloads.ts, 0, 0)) function inner(x:number); // should work ->inner : Symbol(inner, Decl(innerOverloads.ts, 1, 18), Decl(innerOverloads.ts, 2, 29), Decl(innerOverloads.ts, 3, 29)) ->x : Symbol(x, Decl(innerOverloads.ts, 2, 19)) +>inner : Symbol(inner, Decl(innerOverloads.ts, 0, 18), Decl(innerOverloads.ts, 1, 29), Decl(innerOverloads.ts, 2, 29)) +>x : Symbol(x, Decl(innerOverloads.ts, 1, 19)) function inner(x:string); ->inner : Symbol(inner, Decl(innerOverloads.ts, 1, 18), Decl(innerOverloads.ts, 2, 29), Decl(innerOverloads.ts, 3, 29)) ->x : Symbol(x, Decl(innerOverloads.ts, 3, 19)) +>inner : Symbol(inner, Decl(innerOverloads.ts, 0, 18), Decl(innerOverloads.ts, 1, 29), Decl(innerOverloads.ts, 2, 29)) +>x : Symbol(x, Decl(innerOverloads.ts, 2, 19)) function inner(a:any) { return a; } ->inner : Symbol(inner, Decl(innerOverloads.ts, 1, 18), Decl(innerOverloads.ts, 2, 29), Decl(innerOverloads.ts, 3, 29)) ->a : Symbol(a, Decl(innerOverloads.ts, 4, 19)) ->a : Symbol(a, Decl(innerOverloads.ts, 4, 19)) +>inner : Symbol(inner, Decl(innerOverloads.ts, 0, 18), Decl(innerOverloads.ts, 1, 29), Decl(innerOverloads.ts, 2, 29)) +>a : Symbol(a, Decl(innerOverloads.ts, 3, 19)) +>a : Symbol(a, Decl(innerOverloads.ts, 3, 19)) return inner(0); ->inner : Symbol(inner, Decl(innerOverloads.ts, 1, 18), Decl(innerOverloads.ts, 2, 29), Decl(innerOverloads.ts, 3, 29)) +>inner : Symbol(inner, Decl(innerOverloads.ts, 0, 18), Decl(innerOverloads.ts, 1, 29), Decl(innerOverloads.ts, 2, 29)) } var x = outer(); // should work ->x : Symbol(x, Decl(innerOverloads.ts, 9, 3)) +>x : Symbol(x, Decl(innerOverloads.ts, 8, 3)) >outer : Symbol(outer, Decl(innerOverloads.ts, 0, 0)) diff --git a/tests/baselines/reference/innerOverloads.types b/tests/baselines/reference/innerOverloads.types index b15f9e5bf22ff..0d7168ea4e008 100644 --- a/tests/baselines/reference/innerOverloads.types +++ b/tests/baselines/reference/innerOverloads.types @@ -1,5 +1,4 @@ === tests/cases/compiler/innerOverloads.ts === - function outer() { >outer : () => any diff --git a/tests/baselines/reference/instantiatedTypeAliasDisplay.js b/tests/baselines/reference/instantiatedTypeAliasDisplay.js index 9c2b91b613e23..272266e0bea1a 100644 --- a/tests/baselines/reference/instantiatedTypeAliasDisplay.js +++ b/tests/baselines/reference/instantiatedTypeAliasDisplay.js @@ -1,5 +1,4 @@ //// [instantiatedTypeAliasDisplay.ts] - // Repros from #12066 interface X { diff --git a/tests/baselines/reference/instantiatedTypeAliasDisplay.symbols b/tests/baselines/reference/instantiatedTypeAliasDisplay.symbols index fa8140cfcd731..3c6f7d2b725c7 100644 --- a/tests/baselines/reference/instantiatedTypeAliasDisplay.symbols +++ b/tests/baselines/reference/instantiatedTypeAliasDisplay.symbols @@ -1,61 +1,60 @@ === tests/cases/compiler/instantiatedTypeAliasDisplay.ts === - // Repros from #12066 interface X { >X : Symbol(X, Decl(instantiatedTypeAliasDisplay.ts, 0, 0)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 3, 12)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 2, 12)) a: A; ->a : Symbol(X.a, Decl(instantiatedTypeAliasDisplay.ts, 3, 16)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 3, 12)) +>a : Symbol(X.a, Decl(instantiatedTypeAliasDisplay.ts, 2, 16)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 2, 12)) } interface Y { ->Y : Symbol(Y, Decl(instantiatedTypeAliasDisplay.ts, 5, 1)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 6, 12)) +>Y : Symbol(Y, Decl(instantiatedTypeAliasDisplay.ts, 4, 1)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 5, 12)) b: B; ->b : Symbol(Y.b, Decl(instantiatedTypeAliasDisplay.ts, 6, 16)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 6, 12)) +>b : Symbol(Y.b, Decl(instantiatedTypeAliasDisplay.ts, 5, 16)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 5, 12)) } type Z = X | Y; ->Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 8, 1)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 9, 7)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 9, 9)) +>Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 7, 1)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 8, 7)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 8, 9)) >X : Symbol(X, Decl(instantiatedTypeAliasDisplay.ts, 0, 0)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 9, 7)) ->Y : Symbol(Y, Decl(instantiatedTypeAliasDisplay.ts, 5, 1)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 9, 9)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 8, 7)) +>Y : Symbol(Y, Decl(instantiatedTypeAliasDisplay.ts, 4, 1)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 8, 9)) declare function f1(): Z; ->f1 : Symbol(f1, Decl(instantiatedTypeAliasDisplay.ts, 9, 27)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) ->Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 8, 1)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) +>f1 : Symbol(f1, Decl(instantiatedTypeAliasDisplay.ts, 8, 27)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 10, 20)) +>Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 7, 1)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 10, 20)) declare function f2(a: A, b: B, c: C, d: D): Z; ->f2 : Symbol(f2, Decl(instantiatedTypeAliasDisplay.ts, 11, 39)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 12, 20)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 12, 22)) ->C : Symbol(C, Decl(instantiatedTypeAliasDisplay.ts, 12, 25)) ->D : Symbol(D, Decl(instantiatedTypeAliasDisplay.ts, 12, 28)) ->E : Symbol(E, Decl(instantiatedTypeAliasDisplay.ts, 12, 31)) ->a : Symbol(a, Decl(instantiatedTypeAliasDisplay.ts, 12, 35)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 12, 20)) ->b : Symbol(b, Decl(instantiatedTypeAliasDisplay.ts, 12, 40)) ->B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 12, 22)) ->c : Symbol(c, Decl(instantiatedTypeAliasDisplay.ts, 12, 46)) ->C : Symbol(C, Decl(instantiatedTypeAliasDisplay.ts, 12, 25)) ->d : Symbol(d, Decl(instantiatedTypeAliasDisplay.ts, 12, 52)) ->D : Symbol(D, Decl(instantiatedTypeAliasDisplay.ts, 12, 28)) ->Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 8, 1)) ->A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 12, 20)) +>f2 : Symbol(f2, Decl(instantiatedTypeAliasDisplay.ts, 10, 39)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 11, 22)) +>C : Symbol(C, Decl(instantiatedTypeAliasDisplay.ts, 11, 25)) +>D : Symbol(D, Decl(instantiatedTypeAliasDisplay.ts, 11, 28)) +>E : Symbol(E, Decl(instantiatedTypeAliasDisplay.ts, 11, 31)) +>a : Symbol(a, Decl(instantiatedTypeAliasDisplay.ts, 11, 35)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) +>b : Symbol(b, Decl(instantiatedTypeAliasDisplay.ts, 11, 40)) +>B : Symbol(B, Decl(instantiatedTypeAliasDisplay.ts, 11, 22)) +>c : Symbol(c, Decl(instantiatedTypeAliasDisplay.ts, 11, 46)) +>C : Symbol(C, Decl(instantiatedTypeAliasDisplay.ts, 11, 25)) +>d : Symbol(d, Decl(instantiatedTypeAliasDisplay.ts, 11, 52)) +>D : Symbol(D, Decl(instantiatedTypeAliasDisplay.ts, 11, 28)) +>Z : Symbol(Z, Decl(instantiatedTypeAliasDisplay.ts, 7, 1)) +>A : Symbol(A, Decl(instantiatedTypeAliasDisplay.ts, 11, 20)) const x1 = f1(); // Z ->x1 : Symbol(x1, Decl(instantiatedTypeAliasDisplay.ts, 14, 5)) ->f1 : Symbol(f1, Decl(instantiatedTypeAliasDisplay.ts, 9, 27)) +>x1 : Symbol(x1, Decl(instantiatedTypeAliasDisplay.ts, 13, 5)) +>f1 : Symbol(f1, Decl(instantiatedTypeAliasDisplay.ts, 8, 27)) const x2 = f2({}, {}, {}, {}); // Z<{}, string[]> ->x2 : Symbol(x2, Decl(instantiatedTypeAliasDisplay.ts, 15, 5)) ->f2 : Symbol(f2, Decl(instantiatedTypeAliasDisplay.ts, 11, 39)) +>x2 : Symbol(x2, Decl(instantiatedTypeAliasDisplay.ts, 14, 5)) +>f2 : Symbol(f2, Decl(instantiatedTypeAliasDisplay.ts, 10, 39)) diff --git a/tests/baselines/reference/instantiatedTypeAliasDisplay.types b/tests/baselines/reference/instantiatedTypeAliasDisplay.types index 89320e1dba6f1..44885777e7483 100644 --- a/tests/baselines/reference/instantiatedTypeAliasDisplay.types +++ b/tests/baselines/reference/instantiatedTypeAliasDisplay.types @@ -1,5 +1,4 @@ === tests/cases/compiler/instantiatedTypeAliasDisplay.ts === - // Repros from #12066 interface X { diff --git a/tests/baselines/reference/interfaceExtendingClass2.errors.txt b/tests/baselines/reference/interfaceExtendingClass2.errors.txt index 859cb65410eef..3b394d4922ab7 100644 --- a/tests/baselines/reference/interfaceExtendingClass2.errors.txt +++ b/tests/baselines/reference/interfaceExtendingClass2.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(12,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'. -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,13): error TS1131: Property or signature expected. -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,9): error TS1128: Declaration or statement expected. -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(16,5): error TS1128: Declaration or statement expected. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(11,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(13,13): error TS1131: Property or signature expected. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,9): error TS1128: Declaration or statement expected. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,5): error TS1128: Declaration or statement expected. ==== tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts (4 errors) ==== - class Foo { x: string; y() { } diff --git a/tests/baselines/reference/interfaceExtendingClass2.js b/tests/baselines/reference/interfaceExtendingClass2.js index c04ecf1d1bbec..e3ede26b48ed5 100644 --- a/tests/baselines/reference/interfaceExtendingClass2.js +++ b/tests/baselines/reference/interfaceExtendingClass2.js @@ -1,5 +1,4 @@ //// [interfaceExtendingClass2.ts] - class Foo { x: string; y() { } diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.js b/tests/baselines/reference/interfaceExtendsObjectIntersection.js index a6fb62f5070f8..678829edeb84f 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersection.js +++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.js @@ -1,5 +1,4 @@ //// [interfaceExtendsObjectIntersection.ts] - type T1 = { a: number }; type T2 = T1 & { b: number }; type T3 = () => void; diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols b/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols index 16c8c51cf47c4..2c353036af2c2 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols +++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols @@ -1,230 +1,229 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts === - type T1 = { a: number }; >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 1, 11)) +>a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 0, 11)) type T2 = T1 & { b: number }; ->T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 1, 24)) +>T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 0, 24)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 2, 16)) +>b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 1, 16)) type T3 = () => void; ->T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 2, 29)) +>T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 1, 29)) type T4 = new () => { a: number }; ->T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 3, 21)) ->a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 4, 21)) +>T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 2, 21)) +>a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 3, 21)) type T5 = number[]; ->T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 4, 34)) +>T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 3, 34)) type T6 = [string, number]; ->T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 5, 19)) +>T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 4, 19)) type T7 = { [P in 'a' | 'b' | 'c']: string }; ->T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 6, 27)) ->P : Symbol(P, Decl(interfaceExtendsObjectIntersection.ts, 7, 13)) +>T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 5, 27)) +>P : Symbol(P, Decl(interfaceExtendsObjectIntersection.ts, 6, 13)) interface I1 extends T1 { x: string } ->I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 7, 45)) +>I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 6, 45)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(I1.x, Decl(interfaceExtendsObjectIntersection.ts, 9, 25)) +>x : Symbol(I1.x, Decl(interfaceExtendsObjectIntersection.ts, 8, 25)) interface I2 extends T2 { x: string } ->I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 9, 37)) ->T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 1, 24)) ->x : Symbol(I2.x, Decl(interfaceExtendsObjectIntersection.ts, 10, 25)) +>I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 8, 37)) +>T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 0, 24)) +>x : Symbol(I2.x, Decl(interfaceExtendsObjectIntersection.ts, 9, 25)) interface I3 extends T3 { x: string } ->I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 10, 37)) ->T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 2, 29)) ->x : Symbol(I3.x, Decl(interfaceExtendsObjectIntersection.ts, 11, 25)) +>I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 9, 37)) +>T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 1, 29)) +>x : Symbol(I3.x, Decl(interfaceExtendsObjectIntersection.ts, 10, 25)) interface I4 extends T4 { x: string } ->I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 11, 37)) ->T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 3, 21)) ->x : Symbol(I4.x, Decl(interfaceExtendsObjectIntersection.ts, 12, 25)) +>I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 10, 37)) +>T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 2, 21)) +>x : Symbol(I4.x, Decl(interfaceExtendsObjectIntersection.ts, 11, 25)) interface I5 extends T5 { x: string } ->I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 12, 37)) ->T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 4, 34)) ->x : Symbol(I5.x, Decl(interfaceExtendsObjectIntersection.ts, 13, 25)) +>I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 11, 37)) +>T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 3, 34)) +>x : Symbol(I5.x, Decl(interfaceExtendsObjectIntersection.ts, 12, 25)) interface I6 extends T6 { x: string } ->I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 13, 37)) ->T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 5, 19)) ->x : Symbol(I6.x, Decl(interfaceExtendsObjectIntersection.ts, 14, 25)) +>I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 12, 37)) +>T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 4, 19)) +>x : Symbol(I6.x, Decl(interfaceExtendsObjectIntersection.ts, 13, 25)) interface I7 extends T7 { x: string } ->I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 14, 37)) ->T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 6, 27)) ->x : Symbol(I7.x, Decl(interfaceExtendsObjectIntersection.ts, 15, 25)) +>I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 13, 37)) +>T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 5, 27)) +>x : Symbol(I7.x, Decl(interfaceExtendsObjectIntersection.ts, 14, 25)) type Constructor = new () => T; ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 17)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 17)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 16, 17)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 16, 17)) declare function Constructor(): Constructor; ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 18, 29)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 18, 29)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 29)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 29)) class C1 extends Constructor() { x: string } ->C1 : Symbol(C1, Decl(interfaceExtendsObjectIntersection.ts, 18, 50)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 7, 45)) ->x : Symbol(C1.x, Decl(interfaceExtendsObjectIntersection.ts, 20, 36)) +>C1 : Symbol(C1, Decl(interfaceExtendsObjectIntersection.ts, 17, 50)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 6, 45)) +>x : Symbol(C1.x, Decl(interfaceExtendsObjectIntersection.ts, 19, 36)) class C2 extends Constructor() { x: string } ->C2 : Symbol(C2, Decl(interfaceExtendsObjectIntersection.ts, 20, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 9, 37)) ->x : Symbol(C2.x, Decl(interfaceExtendsObjectIntersection.ts, 21, 36)) +>C2 : Symbol(C2, Decl(interfaceExtendsObjectIntersection.ts, 19, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 8, 37)) +>x : Symbol(C2.x, Decl(interfaceExtendsObjectIntersection.ts, 20, 36)) class C3 extends Constructor() { x: string } ->C3 : Symbol(C3, Decl(interfaceExtendsObjectIntersection.ts, 21, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 10, 37)) ->x : Symbol(C3.x, Decl(interfaceExtendsObjectIntersection.ts, 22, 36)) +>C3 : Symbol(C3, Decl(interfaceExtendsObjectIntersection.ts, 20, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 9, 37)) +>x : Symbol(C3.x, Decl(interfaceExtendsObjectIntersection.ts, 21, 36)) class C4 extends Constructor() { x: string } ->C4 : Symbol(C4, Decl(interfaceExtendsObjectIntersection.ts, 22, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 11, 37)) ->x : Symbol(C4.x, Decl(interfaceExtendsObjectIntersection.ts, 23, 36)) +>C4 : Symbol(C4, Decl(interfaceExtendsObjectIntersection.ts, 21, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 10, 37)) +>x : Symbol(C4.x, Decl(interfaceExtendsObjectIntersection.ts, 22, 36)) class C5 extends Constructor() { x: string } ->C5 : Symbol(C5, Decl(interfaceExtendsObjectIntersection.ts, 23, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 12, 37)) ->x : Symbol(C5.x, Decl(interfaceExtendsObjectIntersection.ts, 24, 36)) +>C5 : Symbol(C5, Decl(interfaceExtendsObjectIntersection.ts, 22, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 11, 37)) +>x : Symbol(C5.x, Decl(interfaceExtendsObjectIntersection.ts, 23, 36)) class C6 extends Constructor() { x: string } ->C6 : Symbol(C6, Decl(interfaceExtendsObjectIntersection.ts, 24, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 13, 37)) ->x : Symbol(C6.x, Decl(interfaceExtendsObjectIntersection.ts, 25, 36)) +>C6 : Symbol(C6, Decl(interfaceExtendsObjectIntersection.ts, 23, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 12, 37)) +>x : Symbol(C6.x, Decl(interfaceExtendsObjectIntersection.ts, 24, 36)) class C7 extends Constructor() { x: string } ->C7 : Symbol(C7, Decl(interfaceExtendsObjectIntersection.ts, 25, 48)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 14, 37)) ->x : Symbol(C7.x, Decl(interfaceExtendsObjectIntersection.ts, 26, 36)) +>C7 : Symbol(C7, Decl(interfaceExtendsObjectIntersection.ts, 24, 48)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 13, 37)) +>x : Symbol(C7.x, Decl(interfaceExtendsObjectIntersection.ts, 25, 36)) declare function fx(x: string): string; ->fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 26, 48)) ->x : Symbol(x, Decl(interfaceExtendsObjectIntersection.ts, 28, 20)) +>fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 25, 48)) +>x : Symbol(x, Decl(interfaceExtendsObjectIntersection.ts, 27, 20)) declare class CX { a: number } ->CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 28, 39)) ->a : Symbol(CX.a, Decl(interfaceExtendsObjectIntersection.ts, 29, 18)) +>CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 27, 39)) +>a : Symbol(CX.a, Decl(interfaceExtendsObjectIntersection.ts, 28, 18)) declare enum EX { A, B, C } ->EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 29, 30)) ->A : Symbol(EX.A, Decl(interfaceExtendsObjectIntersection.ts, 30, 17)) ->B : Symbol(EX.B, Decl(interfaceExtendsObjectIntersection.ts, 30, 20)) ->C : Symbol(EX.C, Decl(interfaceExtendsObjectIntersection.ts, 30, 23)) +>EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 28, 30)) +>A : Symbol(EX.A, Decl(interfaceExtendsObjectIntersection.ts, 29, 17)) +>B : Symbol(EX.B, Decl(interfaceExtendsObjectIntersection.ts, 29, 20)) +>C : Symbol(EX.C, Decl(interfaceExtendsObjectIntersection.ts, 29, 23)) declare namespace NX { export const a = 1 } ->NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 30, 27)) ->a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 31, 35)) +>NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 29, 27)) +>a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 30, 35)) type T10 = typeof fx; ->T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 31, 43)) ->fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 26, 48)) +>T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 30, 43)) +>fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 25, 48)) type T11 = typeof CX; ->T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 33, 21)) ->CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 28, 39)) +>T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 32, 21)) +>CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 27, 39)) type T12 = typeof EX; ->T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 34, 21)) ->EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 29, 30)) +>T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 33, 21)) +>EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 28, 30)) type T13 = typeof NX; ->T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 35, 21)) ->NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 30, 27)) +>T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 34, 21)) +>NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 29, 27)) interface I10 extends T10 { x: string } ->I10 : Symbol(I10, Decl(interfaceExtendsObjectIntersection.ts, 36, 21)) ->T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 31, 43)) ->x : Symbol(I10.x, Decl(interfaceExtendsObjectIntersection.ts, 38, 27)) +>I10 : Symbol(I10, Decl(interfaceExtendsObjectIntersection.ts, 35, 21)) +>T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 30, 43)) +>x : Symbol(I10.x, Decl(interfaceExtendsObjectIntersection.ts, 37, 27)) interface I11 extends T11 { x: string } ->I11 : Symbol(I11, Decl(interfaceExtendsObjectIntersection.ts, 38, 39)) ->T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 33, 21)) ->x : Symbol(I11.x, Decl(interfaceExtendsObjectIntersection.ts, 39, 27)) +>I11 : Symbol(I11, Decl(interfaceExtendsObjectIntersection.ts, 37, 39)) +>T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 32, 21)) +>x : Symbol(I11.x, Decl(interfaceExtendsObjectIntersection.ts, 38, 27)) interface I12 extends T12 { x: string } ->I12 : Symbol(I12, Decl(interfaceExtendsObjectIntersection.ts, 39, 39)) ->T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 34, 21)) ->x : Symbol(I12.x, Decl(interfaceExtendsObjectIntersection.ts, 40, 27)) +>I12 : Symbol(I12, Decl(interfaceExtendsObjectIntersection.ts, 38, 39)) +>T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 33, 21)) +>x : Symbol(I12.x, Decl(interfaceExtendsObjectIntersection.ts, 39, 27)) interface I13 extends T13 { x: string } ->I13 : Symbol(I13, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) ->T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 35, 21)) ->x : Symbol(I13.x, Decl(interfaceExtendsObjectIntersection.ts, 41, 27)) +>I13 : Symbol(I13, Decl(interfaceExtendsObjectIntersection.ts, 39, 39)) +>T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 34, 21)) +>x : Symbol(I13.x, Decl(interfaceExtendsObjectIntersection.ts, 40, 27)) type Identifiable = { _id: string } & T; ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 43, 18)) ->_id : Symbol(_id, Decl(interfaceExtendsObjectIntersection.ts, 43, 24)) ->T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 43, 18)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 42, 18)) +>_id : Symbol(_id, Decl(interfaceExtendsObjectIntersection.ts, 42, 24)) +>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 42, 18)) interface I20 extends Partial { x: string } ->I20 : Symbol(I20, Decl(interfaceExtendsObjectIntersection.ts, 43, 43)) +>I20 : Symbol(I20, Decl(interfaceExtendsObjectIntersection.ts, 42, 43)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(I20.x, Decl(interfaceExtendsObjectIntersection.ts, 45, 35)) +>x : Symbol(I20.x, Decl(interfaceExtendsObjectIntersection.ts, 44, 35)) interface I21 extends Readonly { x: string } ->I21 : Symbol(I21, Decl(interfaceExtendsObjectIntersection.ts, 45, 47)) +>I21 : Symbol(I21, Decl(interfaceExtendsObjectIntersection.ts, 44, 47)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(I21.x, Decl(interfaceExtendsObjectIntersection.ts, 46, 36)) +>x : Symbol(I21.x, Decl(interfaceExtendsObjectIntersection.ts, 45, 36)) interface I22 extends Identifiable { x: string } ->I22 : Symbol(I22, Decl(interfaceExtendsObjectIntersection.ts, 46, 48)) ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) +>I22 : Symbol(I22, Decl(interfaceExtendsObjectIntersection.ts, 45, 48)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(I22.x, Decl(interfaceExtendsObjectIntersection.ts, 47, 40)) +>x : Symbol(I22.x, Decl(interfaceExtendsObjectIntersection.ts, 46, 40)) interface I23 extends Identifiable { x: string } ->I23 : Symbol(I23, Decl(interfaceExtendsObjectIntersection.ts, 47, 52)) ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) +>I23 : Symbol(I23, Decl(interfaceExtendsObjectIntersection.ts, 46, 52)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 48, 41)) ->x : Symbol(I23.x, Decl(interfaceExtendsObjectIntersection.ts, 48, 55)) +>b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 47, 41)) +>x : Symbol(I23.x, Decl(interfaceExtendsObjectIntersection.ts, 47, 55)) class C20 extends Constructor>() { x: string } ->C20 : Symbol(C20, Decl(interfaceExtendsObjectIntersection.ts, 48, 67)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) +>C20 : Symbol(C20, Decl(interfaceExtendsObjectIntersection.ts, 47, 67)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(C20.x, Decl(interfaceExtendsObjectIntersection.ts, 50, 46)) +>x : Symbol(C20.x, Decl(interfaceExtendsObjectIntersection.ts, 49, 46)) class C21 extends Constructor>() { x: string } ->C21 : Symbol(C21, Decl(interfaceExtendsObjectIntersection.ts, 50, 58)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) +>C21 : Symbol(C21, Decl(interfaceExtendsObjectIntersection.ts, 49, 58)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(C21.x, Decl(interfaceExtendsObjectIntersection.ts, 51, 47)) +>x : Symbol(C21.x, Decl(interfaceExtendsObjectIntersection.ts, 50, 47)) class C22 extends Constructor>() { x: string } ->C22 : Symbol(C22, Decl(interfaceExtendsObjectIntersection.ts, 51, 59)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) +>C22 : Symbol(C22, Decl(interfaceExtendsObjectIntersection.ts, 50, 59)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->x : Symbol(C22.x, Decl(interfaceExtendsObjectIntersection.ts, 52, 51)) +>x : Symbol(C22.x, Decl(interfaceExtendsObjectIntersection.ts, 51, 51)) class C23 extends Constructor>() { x: string } ->C23 : Symbol(C23, Decl(interfaceExtendsObjectIntersection.ts, 52, 63)) ->Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34)) ->Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39)) +>C23 : Symbol(C23, Decl(interfaceExtendsObjectIntersection.ts, 51, 63)) +>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 14, 37), Decl(interfaceExtendsObjectIntersection.ts, 16, 34)) +>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 40, 39)) >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0)) ->b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 53, 49)) ->x : Symbol(C23.x, Decl(interfaceExtendsObjectIntersection.ts, 53, 66)) +>b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 52, 49)) +>x : Symbol(C23.x, Decl(interfaceExtendsObjectIntersection.ts, 52, 66)) diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.types b/tests/baselines/reference/interfaceExtendsObjectIntersection.types index 1ff550df7b4d3..50ef0339b938f 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersection.types +++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.types @@ -1,5 +1,4 @@ === tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts === - type T1 = { a: number }; >T1 : T1 >a : number diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt index 839474b3bdca0..155cf4bd5add4 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt +++ b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt @@ -1,68 +1,67 @@ -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(8,11): error TS2430: Interface 'I1' incorrectly extends interface 'T1'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(7,11): error TS2430: Interface 'I1' incorrectly extends interface 'T1'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(9,11): error TS2430: Interface 'I2' incorrectly extends interface 'T2'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(8,11): error TS2430: Interface 'I2' incorrectly extends interface 'T2'. Type 'I2' is not assignable to type '{ b: number; }'. Types of property 'b' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(10,11): error TS2430: Interface 'I3' incorrectly extends interface 'number[]'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(9,11): error TS2430: Interface 'I3' incorrectly extends interface 'number[]'. Types of property 'length' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(11,11): error TS2430: Interface 'I4' incorrectly extends interface '[string, number]'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(10,11): error TS2430: Interface 'I4' incorrectly extends interface '[string, number]'. Types of property '0' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(12,11): error TS2430: Interface 'I5' incorrectly extends interface 'T5'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(11,11): error TS2430: Interface 'I5' incorrectly extends interface 'T5'. Types of property 'c' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(17,7): error TS2415: Class 'C1' incorrectly extends base class 'T1'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(16,7): error TS2415: Class 'C1' incorrectly extends base class 'T1'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(18,7): error TS2415: Class 'C2' incorrectly extends base class 'T2'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(17,7): error TS2415: Class 'C2' incorrectly extends base class 'T2'. Type 'C2' is not assignable to type '{ b: number; }'. Types of property 'b' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(19,7): error TS2415: Class 'C3' incorrectly extends base class 'number[]'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(18,7): error TS2415: Class 'C3' incorrectly extends base class 'number[]'. Types of property 'length' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(20,7): error TS2415: Class 'C4' incorrectly extends base class '[string, number]'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(19,7): error TS2415: Class 'C4' incorrectly extends base class '[string, number]'. Types of property '0' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(21,7): error TS2415: Class 'C5' incorrectly extends base class 'T5'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(20,7): error TS2415: Class 'C5' incorrectly extends base class 'T5'. Types of property 'c' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(31,11): error TS2430: Interface 'I10' incorrectly extends interface 'typeof CX'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(30,11): error TS2430: Interface 'I10' incorrectly extends interface 'typeof CX'. Types of property 'a' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(32,11): error TS2430: Interface 'I11' incorrectly extends interface 'typeof EX'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(31,11): error TS2430: Interface 'I11' incorrectly extends interface 'typeof EX'. Types of property 'C' are incompatible. Type 'string' is not assignable to type 'EX'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(33,11): error TS2430: Interface 'I12' incorrectly extends interface 'typeof NX'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(32,11): error TS2430: Interface 'I12' incorrectly extends interface 'typeof NX'. Types of property 'a' are incompatible. Type 'number' is not assignable to type '"hello"'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(34,29): error TS2411: Property 'a' of type 'string' is not assignable to string index type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(34,29): error TS2411: Property 'prototype' of type 'CX' is not assignable to string index type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(35,29): error TS2413: Numeric index type 'string' is not assignable to string index type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(36,29): error TS2411: Property 'a' of type '"hello"' is not assignable to string index type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(40,11): error TS2430: Interface 'I20' incorrectly extends interface 'Partial'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(33,29): error TS2411: Property 'a' of type 'string' is not assignable to string index type 'number'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(33,29): error TS2411: Property 'prototype' of type 'CX' is not assignable to string index type 'number'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(34,29): error TS2413: Numeric index type 'string' is not assignable to string index type 'number'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(35,29): error TS2411: Property 'a' of type '"hello"' is not assignable to string index type 'number'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(39,11): error TS2430: Interface 'I20' incorrectly extends interface 'Partial'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number | undefined'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(41,11): error TS2430: Interface 'I21' incorrectly extends interface 'Readonly'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(40,11): error TS2430: Interface 'I21' incorrectly extends interface 'Readonly'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(42,11): error TS2430: Interface 'I22' incorrectly extends interface 'Identifiable'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(41,11): error TS2430: Interface 'I22' incorrectly extends interface 'Identifiable'. Type 'I22' is not assignable to type 'T1'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(43,11): error TS2430: Interface 'I23' incorrectly extends interface 'Identifiable'. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(42,11): error TS2430: Interface 'I23' incorrectly extends interface 'Identifiable'. Type 'I23' is not assignable to type 'T1'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(47,23): error TS2312: An interface may only extend a class or another interface. -tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(48,26): error TS2312: An interface may only extend a class or another interface. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(46,23): error TS2312: An interface may only extend a class or another interface. +tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(47,26): error TS2312: An interface may only extend a class or another interface. ==== tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts (23 errors) ==== - type T1 = { a: number }; type T2 = T1 & { b: number }; type T3 = number[]; diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js index 61f84b2f7feb7..7ae09d693ffb2 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js +++ b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js @@ -1,5 +1,4 @@ //// [interfaceExtendsObjectIntersectionErrors.ts] - type T1 = { a: number }; type T2 = T1 & { b: number }; type T3 = number[]; diff --git a/tests/baselines/reference/interfaceWithOptionalProperty.js b/tests/baselines/reference/interfaceWithOptionalProperty.js index 5e62fb5257bec..dd70f24538219 100644 --- a/tests/baselines/reference/interfaceWithOptionalProperty.js +++ b/tests/baselines/reference/interfaceWithOptionalProperty.js @@ -1,5 +1,4 @@ //// [interfaceWithOptionalProperty.ts] - interface I { x?: number; } diff --git a/tests/baselines/reference/interfaceWithOptionalProperty.symbols b/tests/baselines/reference/interfaceWithOptionalProperty.symbols index 90e5b66669325..c22c1a67c3b28 100644 --- a/tests/baselines/reference/interfaceWithOptionalProperty.symbols +++ b/tests/baselines/reference/interfaceWithOptionalProperty.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/interfaceWithOptionalProperty.ts === - interface I { >I : Symbol(I, Decl(interfaceWithOptionalProperty.ts, 0, 0)) x?: number; ->x : Symbol(I.x, Decl(interfaceWithOptionalProperty.ts, 1, 13)) +>x : Symbol(I.x, Decl(interfaceWithOptionalProperty.ts, 0, 13)) } diff --git a/tests/baselines/reference/interfaceWithOptionalProperty.types b/tests/baselines/reference/interfaceWithOptionalProperty.types index 862857483da02..667e410748c67 100644 --- a/tests/baselines/reference/interfaceWithOptionalProperty.types +++ b/tests/baselines/reference/interfaceWithOptionalProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/interfaceWithOptionalProperty.ts === - interface I { >I : I diff --git a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt index ecbd9ec293c29..ab003895ff0f6 100644 --- a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt +++ b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(5,5): error TS1070: 'private' modifier cannot appear on a type member. -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(9,5): error TS1070: 'private' modifier cannot appear on a type member. -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,5): error TS1070: 'private' modifier cannot appear on a type member. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(4,5): error TS1070: 'private' modifier cannot appear on a type member. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(8,5): error TS1070: 'private' modifier cannot appear on a type member. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(12,5): error TS1070: 'private' modifier cannot appear on a type member. ==== tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts (3 errors) ==== - // interfaces do not permit private members, these are errors interface I { diff --git a/tests/baselines/reference/interfaceWithPrivateMember.js b/tests/baselines/reference/interfaceWithPrivateMember.js index d59037cf058cc..06bcb537f55d6 100644 --- a/tests/baselines/reference/interfaceWithPrivateMember.js +++ b/tests/baselines/reference/interfaceWithPrivateMember.js @@ -1,5 +1,4 @@ //// [interfaceWithPrivateMember.ts] - // interfaces do not permit private members, these are errors interface I { diff --git a/tests/baselines/reference/intersectionTypeInference1.js b/tests/baselines/reference/intersectionTypeInference1.js index 32ddedae2b3c1..e13f8edf0cffd 100644 --- a/tests/baselines/reference/intersectionTypeInference1.js +++ b/tests/baselines/reference/intersectionTypeInference1.js @@ -9,8 +9,8 @@ export const Form3 = brokenFunction(parameterFn)({store: "hello"}) //// [intersectionTypeInference1.js] -// Repro from #8801 "use strict"; +// Repro from #8801 exports.__esModule = true; function alert(s) { } var parameterFn = function (props) { return alert(props.store); }; diff --git a/tests/baselines/reference/intersectionsAndEmptyObjects.js b/tests/baselines/reference/intersectionsAndEmptyObjects.js new file mode 100644 index 0000000000000..1ac9606c3a9bf --- /dev/null +++ b/tests/baselines/reference/intersectionsAndEmptyObjects.js @@ -0,0 +1,45 @@ +//// [intersectionsAndEmptyObjects.ts] +// Empty object type literals are removed from intersections types +// that contain other object types + +type A = { a: number }; +type B = { b: string }; +type C = {}; + +let x01: A & B; +let x02: A & C; +let x03: B & C; +let x04: A & B & C; +let x05: string & C; +let x06: C & string; +let x07: C; +let x08: C & {}; +let x09: {} & A & {} & B & {} & C & {}; + +interface D {} +interface E {} + +let x10: A & D; +let x11: C & D; +let x12: A & B & C & D; +let x13: D & E; +let x14: A & B & C & D & E; + + +//// [intersectionsAndEmptyObjects.js] +// Empty object type literals are removed from intersections types +// that contain other object types +var x01; +var x02; +var x03; +var x04; +var x05; +var x06; +var x07; +var x08; +var x09; +var x10; +var x11; +var x12; +var x13; +var x14; diff --git a/tests/baselines/reference/intersectionsAndEmptyObjects.symbols b/tests/baselines/reference/intersectionsAndEmptyObjects.symbols new file mode 100644 index 0000000000000..14189a1c10b81 --- /dev/null +++ b/tests/baselines/reference/intersectionsAndEmptyObjects.symbols @@ -0,0 +1,94 @@ +=== tests/cases/conformance/types/intersection/intersectionsAndEmptyObjects.ts === +// Empty object type literals are removed from intersections types +// that contain other object types + +type A = { a: number }; +>A : Symbol(A, Decl(intersectionsAndEmptyObjects.ts, 0, 0)) +>a : Symbol(a, Decl(intersectionsAndEmptyObjects.ts, 3, 10)) + +type B = { b: string }; +>B : Symbol(B, Decl(intersectionsAndEmptyObjects.ts, 3, 23)) +>b : Symbol(b, Decl(intersectionsAndEmptyObjects.ts, 4, 10)) + +type C = {}; +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) + +let x01: A & B; +>x01 : Symbol(x01, Decl(intersectionsAndEmptyObjects.ts, 7, 3)) +>A : Symbol(A, Decl(intersectionsAndEmptyObjects.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionsAndEmptyObjects.ts, 3, 23)) + +let x02: A & C; +>x02 : Symbol(x02, Decl(intersectionsAndEmptyObjects.ts, 8, 3)) +>A : Symbol(A, Decl(intersectionsAndEmptyObjects.ts, 0, 0)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) + +let x03: B & C; +>x03 : Symbol(x03, Decl(intersectionsAndEmptyObjects.ts, 9, 3)) +>B : Symbol(B, Decl(intersectionsAndEmptyObjects.ts, 3, 23)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) + +let x04: A & B & C; +>x04 : Symbol(x04, Decl(intersectionsAndEmptyObjects.ts, 10, 3)) +>A : Symbol(A, Decl(intersectionsAndEmptyObjects.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionsAndEmptyObjects.ts, 3, 23)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) + +let x05: string & C; +>x05 : Symbol(x05, Decl(intersectionsAndEmptyObjects.ts, 11, 3)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) + +let x06: C & string; +>x06 : Symbol(x06, Decl(intersectionsAndEmptyObjects.ts, 12, 3)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) + +let x07: C; +>x07 : Symbol(x07, Decl(intersectionsAndEmptyObjects.ts, 13, 3)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) + +let x08: C & {}; +>x08 : Symbol(x08, Decl(intersectionsAndEmptyObjects.ts, 14, 3)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) + +let x09: {} & A & {} & B & {} & C & {}; +>x09 : Symbol(x09, Decl(intersectionsAndEmptyObjects.ts, 15, 3)) +>A : Symbol(A, Decl(intersectionsAndEmptyObjects.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionsAndEmptyObjects.ts, 3, 23)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) + +interface D {} +>D : Symbol(D, Decl(intersectionsAndEmptyObjects.ts, 15, 39)) + +interface E {} +>E : Symbol(E, Decl(intersectionsAndEmptyObjects.ts, 17, 14)) + +let x10: A & D; +>x10 : Symbol(x10, Decl(intersectionsAndEmptyObjects.ts, 20, 3)) +>A : Symbol(A, Decl(intersectionsAndEmptyObjects.ts, 0, 0)) +>D : Symbol(D, Decl(intersectionsAndEmptyObjects.ts, 15, 39)) + +let x11: C & D; +>x11 : Symbol(x11, Decl(intersectionsAndEmptyObjects.ts, 21, 3)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) +>D : Symbol(D, Decl(intersectionsAndEmptyObjects.ts, 15, 39)) + +let x12: A & B & C & D; +>x12 : Symbol(x12, Decl(intersectionsAndEmptyObjects.ts, 22, 3)) +>A : Symbol(A, Decl(intersectionsAndEmptyObjects.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionsAndEmptyObjects.ts, 3, 23)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) +>D : Symbol(D, Decl(intersectionsAndEmptyObjects.ts, 15, 39)) + +let x13: D & E; +>x13 : Symbol(x13, Decl(intersectionsAndEmptyObjects.ts, 23, 3)) +>D : Symbol(D, Decl(intersectionsAndEmptyObjects.ts, 15, 39)) +>E : Symbol(E, Decl(intersectionsAndEmptyObjects.ts, 17, 14)) + +let x14: A & B & C & D & E; +>x14 : Symbol(x14, Decl(intersectionsAndEmptyObjects.ts, 24, 3)) +>A : Symbol(A, Decl(intersectionsAndEmptyObjects.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionsAndEmptyObjects.ts, 3, 23)) +>C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23)) +>D : Symbol(D, Decl(intersectionsAndEmptyObjects.ts, 15, 39)) +>E : Symbol(E, Decl(intersectionsAndEmptyObjects.ts, 17, 14)) + diff --git a/tests/baselines/reference/intersectionsAndEmptyObjects.types b/tests/baselines/reference/intersectionsAndEmptyObjects.types new file mode 100644 index 0000000000000..b3db1764e3c80 --- /dev/null +++ b/tests/baselines/reference/intersectionsAndEmptyObjects.types @@ -0,0 +1,94 @@ +=== tests/cases/conformance/types/intersection/intersectionsAndEmptyObjects.ts === +// Empty object type literals are removed from intersections types +// that contain other object types + +type A = { a: number }; +>A : A +>a : number + +type B = { b: string }; +>B : B +>b : string + +type C = {}; +>C : C + +let x01: A & B; +>x01 : A & B +>A : A +>B : B + +let x02: A & C; +>x02 : A +>A : A +>C : C + +let x03: B & C; +>x03 : B +>B : B +>C : C + +let x04: A & B & C; +>x04 : A & B +>A : A +>B : B +>C : C + +let x05: string & C; +>x05 : string & {} +>C : C + +let x06: C & string; +>x06 : string & {} +>C : C + +let x07: C; +>x07 : C +>C : C + +let x08: C & {}; +>x08 : {} +>C : C + +let x09: {} & A & {} & B & {} & C & {}; +>x09 : A & B +>A : A +>B : B +>C : C + +interface D {} +>D : D + +interface E {} +>E : E + +let x10: A & D; +>x10 : A & D +>A : A +>D : D + +let x11: C & D; +>x11 : D +>C : C +>D : D + +let x12: A & B & C & D; +>x12 : A & B & D +>A : A +>B : B +>C : C +>D : D + +let x13: D & E; +>x13 : D & E +>D : D +>E : E + +let x14: A & B & C & D & E; +>x14 : A & B & D & E +>A : A +>B : B +>C : C +>D : D +>E : E + diff --git a/tests/baselines/reference/intrinsics.errors.txt b/tests/baselines/reference/intrinsics.errors.txt index 342b84e02b995..5692f057903e5 100644 --- a/tests/baselines/reference/intrinsics.errors.txt +++ b/tests/baselines/reference/intrinsics.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/intrinsics.ts(2,21): error TS2304: Cannot find name 'hasOwnProperty'. -tests/cases/compiler/intrinsics.ts(2,21): error TS4025: Exported variable 'hasOwnProperty' has or is using private name 'hasOwnProperty'. -tests/cases/compiler/intrinsics.ts(11,1): error TS2304: Cannot find name '__proto__'. +tests/cases/compiler/intrinsics.ts(1,21): error TS2304: Cannot find name 'hasOwnProperty'. +tests/cases/compiler/intrinsics.ts(1,21): error TS4025: Exported variable 'hasOwnProperty' has or is using private name 'hasOwnProperty'. +tests/cases/compiler/intrinsics.ts(10,1): error TS2304: Cannot find name '__proto__'. ==== tests/cases/compiler/intrinsics.ts (3 errors) ==== - var hasOwnProperty: hasOwnProperty; // Error ~~~~~~~~~~~~~~ !!! error TS2304: Cannot find name 'hasOwnProperty'. diff --git a/tests/baselines/reference/intrinsics.js b/tests/baselines/reference/intrinsics.js index 548c72b1b40f7..82f6ceda758b1 100644 --- a/tests/baselines/reference/intrinsics.js +++ b/tests/baselines/reference/intrinsics.js @@ -1,5 +1,4 @@ //// [intrinsics.ts] - var hasOwnProperty: hasOwnProperty; // Error module m1 { diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt index 15983bd1fc40f..65fd55b763baa 100644 --- a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(9,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(8,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. ==== tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts (6 errors) ==== - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.js b/tests/baselines/reference/invalidDoWhileBreakStatements.js index 4f48a890aa658..807d58a8fea44 100644 --- a/tests/baselines/reference/invalidDoWhileBreakStatements.js +++ b/tests/baselines/reference/invalidDoWhileBreakStatements.js @@ -1,5 +1,4 @@ //// [invalidDoWhileBreakStatements.ts] - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt index 3a520209293e5..e9643394d1215 100644 --- a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(9,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(8,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts (6 errors) ==== - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.js b/tests/baselines/reference/invalidDoWhileContinueStatements.js index b77259159a9dc..21a10a3451bb5 100644 --- a/tests/baselines/reference/invalidDoWhileContinueStatements.js +++ b/tests/baselines/reference/invalidDoWhileContinueStatements.js @@ -1,5 +1,4 @@ //// [invalidDoWhileContinueStatements.ts] - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForBreakStatements.errors.txt b/tests/baselines/reference/invalidForBreakStatements.errors.txt index 57ae1d32c8e50..50e4013c0eac4 100644 --- a/tests/baselines/reference/invalidForBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidForBreakStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(9,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(8,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(36,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. ==== tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts (6 errors) ==== - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForBreakStatements.js b/tests/baselines/reference/invalidForBreakStatements.js index 50096e1672029..5e3430ecb417d 100644 --- a/tests/baselines/reference/invalidForBreakStatements.js +++ b/tests/baselines/reference/invalidForBreakStatements.js @@ -1,5 +1,4 @@ //// [invalidForBreakStatements.ts] - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForContinueStatements.errors.txt b/tests/baselines/reference/invalidForContinueStatements.errors.txt index 9ebfae57e9f70..3af47370df156 100644 --- a/tests/baselines/reference/invalidForContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidForContinueStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(9,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(8,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(36,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts (6 errors) ==== - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForContinueStatements.js b/tests/baselines/reference/invalidForContinueStatements.js index 7a3513bb2a394..2db1ce69ede00 100644 --- a/tests/baselines/reference/invalidForContinueStatements.js +++ b/tests/baselines/reference/invalidForContinueStatements.js @@ -1,5 +1,4 @@ //// [invalidForContinueStatements.ts] - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForInBreakStatements.errors.txt b/tests/baselines/reference/invalidForInBreakStatements.errors.txt index b1f5d64f973e9..d83304ab1c674 100644 --- a/tests/baselines/reference/invalidForInBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidForInBreakStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(9,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(8,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. ==== tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts (6 errors) ==== - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForInBreakStatements.js b/tests/baselines/reference/invalidForInBreakStatements.js index 11517f2a02027..1784b9a57a61d 100644 --- a/tests/baselines/reference/invalidForInBreakStatements.js +++ b/tests/baselines/reference/invalidForInBreakStatements.js @@ -1,5 +1,4 @@ //// [invalidForInBreakStatements.ts] - // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForInContinueStatements.errors.txt b/tests/baselines/reference/invalidForInContinueStatements.errors.txt index f20d9c6e81c6b..7353a22d9cd8a 100644 --- a/tests/baselines/reference/invalidForInContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidForInContinueStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(9,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(8,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts (6 errors) ==== - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForInContinueStatements.js b/tests/baselines/reference/invalidForInContinueStatements.js index 5eb0e10bf5361..94020d00f2b50 100644 --- a/tests/baselines/reference/invalidForInContinueStatements.js +++ b/tests/baselines/reference/invalidForInContinueStatements.js @@ -1,5 +1,4 @@ //// [invalidForInContinueStatements.ts] - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidSyntaxNamespaceImportWithAMD.errors.txt b/tests/baselines/reference/invalidSyntaxNamespaceImportWithAMD.errors.txt new file mode 100644 index 0000000000000..97afe586046e9 --- /dev/null +++ b/tests/baselines/reference/invalidSyntaxNamespaceImportWithAMD.errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/externalModules/1.ts(1,10): error TS1005: 'as' expected. +tests/cases/conformance/externalModules/1.ts(1,15): error TS1005: 'from' expected. +tests/cases/conformance/externalModules/1.ts(1,15): error TS1141: String literal expected. +tests/cases/conformance/externalModules/1.ts(1,20): error TS1005: ';' expected. +tests/cases/conformance/externalModules/1.ts(1,25): error TS1005: ';' expected. + + +==== tests/cases/conformance/externalModules/0.ts (0 errors) ==== + export class C { } + +==== tests/cases/conformance/externalModules/1.ts (5 errors) ==== + import * from Zero from "./0" + ~~~~ +!!! error TS1005: 'as' expected. + ~~~~ +!!! error TS1005: 'from' expected. + ~~~~ +!!! error TS1141: String literal expected. + ~~~~ +!!! error TS1005: ';' expected. + ~~~~~ +!!! error TS1005: ';' expected. \ No newline at end of file diff --git a/tests/baselines/reference/invalidSyntaxNamespaceImportWithAMD.js b/tests/baselines/reference/invalidSyntaxNamespaceImportWithAMD.js new file mode 100644 index 0000000000000..b2adf37b5020f --- /dev/null +++ b/tests/baselines/reference/invalidSyntaxNamespaceImportWithAMD.js @@ -0,0 +1,26 @@ +//// [tests/cases/conformance/externalModules/invalidSyntaxNamespaceImportWithAMD.ts] //// + +//// [0.ts] +export class C { } + +//// [1.ts] +import * from Zero from "./0" + +//// [0.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + exports.__esModule = true; + var C = (function () { + function C() { + } + return C; + }()); + exports.C = C; +}); +//// [1.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + exports.__esModule = true; + from; + "./0"; +}); diff --git a/tests/baselines/reference/invalidSyntaxNamespaceImportWithCommonjs.errors.txt b/tests/baselines/reference/invalidSyntaxNamespaceImportWithCommonjs.errors.txt new file mode 100644 index 0000000000000..97afe586046e9 --- /dev/null +++ b/tests/baselines/reference/invalidSyntaxNamespaceImportWithCommonjs.errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/externalModules/1.ts(1,10): error TS1005: 'as' expected. +tests/cases/conformance/externalModules/1.ts(1,15): error TS1005: 'from' expected. +tests/cases/conformance/externalModules/1.ts(1,15): error TS1141: String literal expected. +tests/cases/conformance/externalModules/1.ts(1,20): error TS1005: ';' expected. +tests/cases/conformance/externalModules/1.ts(1,25): error TS1005: ';' expected. + + +==== tests/cases/conformance/externalModules/0.ts (0 errors) ==== + export class C { } + +==== tests/cases/conformance/externalModules/1.ts (5 errors) ==== + import * from Zero from "./0" + ~~~~ +!!! error TS1005: 'as' expected. + ~~~~ +!!! error TS1005: 'from' expected. + ~~~~ +!!! error TS1141: String literal expected. + ~~~~ +!!! error TS1005: ';' expected. + ~~~~~ +!!! error TS1005: ';' expected. \ No newline at end of file diff --git a/tests/baselines/reference/invalidSyntaxNamespaceImportWithCommonjs.js b/tests/baselines/reference/invalidSyntaxNamespaceImportWithCommonjs.js new file mode 100644 index 0000000000000..b1ab6fc6aa393 --- /dev/null +++ b/tests/baselines/reference/invalidSyntaxNamespaceImportWithCommonjs.js @@ -0,0 +1,23 @@ +//// [tests/cases/conformance/externalModules/invalidSyntaxNamespaceImportWithCommonjs.ts] //// + +//// [0.ts] +export class C { } + +//// [1.ts] +import * from Zero from "./0" + +//// [0.js] +"use strict"; +exports.__esModule = true; +var C = (function () { + function C() { + } + return C; +}()); +exports.C = C; +//// [1.js] +"use strict"; +exports.__esModule = true; +var from = require(); +from; +"./0"; diff --git a/tests/baselines/reference/invalidSyntaxNamespaceImportWithSystem.errors.txt b/tests/baselines/reference/invalidSyntaxNamespaceImportWithSystem.errors.txt new file mode 100644 index 0000000000000..97afe586046e9 --- /dev/null +++ b/tests/baselines/reference/invalidSyntaxNamespaceImportWithSystem.errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/externalModules/1.ts(1,10): error TS1005: 'as' expected. +tests/cases/conformance/externalModules/1.ts(1,15): error TS1005: 'from' expected. +tests/cases/conformance/externalModules/1.ts(1,15): error TS1141: String literal expected. +tests/cases/conformance/externalModules/1.ts(1,20): error TS1005: ';' expected. +tests/cases/conformance/externalModules/1.ts(1,25): error TS1005: ';' expected. + + +==== tests/cases/conformance/externalModules/0.ts (0 errors) ==== + export class C { } + +==== tests/cases/conformance/externalModules/1.ts (5 errors) ==== + import * from Zero from "./0" + ~~~~ +!!! error TS1005: 'as' expected. + ~~~~ +!!! error TS1005: 'from' expected. + ~~~~ +!!! error TS1141: String literal expected. + ~~~~ +!!! error TS1005: ';' expected. + ~~~~~ +!!! error TS1005: ';' expected. \ No newline at end of file diff --git a/tests/baselines/reference/invalidSyntaxNamespaceImportWithSystem.js b/tests/baselines/reference/invalidSyntaxNamespaceImportWithSystem.js new file mode 100644 index 0000000000000..50e23aae57541 --- /dev/null +++ b/tests/baselines/reference/invalidSyntaxNamespaceImportWithSystem.js @@ -0,0 +1,38 @@ +//// [tests/cases/conformance/externalModules/invalidSyntaxNamespaceImportWithSystem.ts] //// + +//// [0.ts] +export class C { } + +//// [1.ts] +import * from Zero from "./0" + +//// [0.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var __moduleName = context_1 && context_1.id; + var C; + return { + setters: [], + execute: function () { + C = (function () { + function C() { + } + return C; + }()); + exports_1("C", C); + } + }; +}); +//// [1.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var __moduleName = context_1 && context_1.id; + var from; + return { + setters: [], + execute: function () { + from; + "./0"; + } + }; +}); diff --git a/tests/baselines/reference/invalidThrowStatement.errors.txt b/tests/baselines/reference/invalidThrowStatement.errors.txt index 3002bce2f1f34..b30549a217c27 100644 --- a/tests/baselines/reference/invalidThrowStatement.errors.txt +++ b/tests/baselines/reference/invalidThrowStatement.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(2,6): error TS1109: Expression expected. -tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(1,6): error TS1109: Expression expected. +tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(3,1): error TS1128: Declaration or statement expected. ==== tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts (2 errors) ==== - throw; ~ !!! error TS1109: Expression expected. diff --git a/tests/baselines/reference/invalidThrowStatement.js b/tests/baselines/reference/invalidThrowStatement.js index 674dacf5c17fc..4b794ab3d517a 100644 --- a/tests/baselines/reference/invalidThrowStatement.js +++ b/tests/baselines/reference/invalidThrowStatement.js @@ -1,5 +1,4 @@ //// [invalidThrowStatement.ts] - throw; export throw null; diff --git a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt index e7a9ed13c4033..462b244efd43a 100644 --- a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(9,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(8,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts (6 errors) ==== - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidWhileContinueStatements.js b/tests/baselines/reference/invalidWhileContinueStatements.js index 16350e9b561f0..b8234bf96045c 100644 --- a/tests/baselines/reference/invalidWhileContinueStatements.js +++ b/tests/baselines/reference/invalidWhileContinueStatements.js @@ -1,5 +1,4 @@ //// [invalidWhileContinueStatements.ts] - // All errors // naked continue not allowed diff --git a/tests/baselines/reference/isDeclarationVisibleNodeKinds.js b/tests/baselines/reference/isDeclarationVisibleNodeKinds.js index 07bc999474232..cf25d8e7e236b 100644 --- a/tests/baselines/reference/isDeclarationVisibleNodeKinds.js +++ b/tests/baselines/reference/isDeclarationVisibleNodeKinds.js @@ -1,5 +1,4 @@ //// [isDeclarationVisibleNodeKinds.ts] - // Function types module schema { export function createValidator1(schema: any): (data: T) => T { diff --git a/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols b/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols index ecc68121f3751..06d1f087d0928 100644 --- a/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols +++ b/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/isDeclarationVisibleNodeKinds.ts === - // Function types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator1(schema: any): (data: T) => T { ->createValidator1 : Symbol(createValidator1, Decl(isDeclarationVisibleNodeKinds.ts, 2, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 3, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 3, 52)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 3, 55)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 3, 52)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 3, 52)) +>createValidator1 : Symbol(createValidator1, Decl(isDeclarationVisibleNodeKinds.ts, 1, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 2, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 2, 52)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 2, 55)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 2, 52)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 2, 52)) return undefined; >undefined : Symbol(undefined) @@ -19,15 +18,15 @@ module schema { // Constructor types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator2(schema: any): new (data: T) => T { ->createValidator2 : Symbol(createValidator2, Decl(isDeclarationVisibleNodeKinds.ts, 9, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 10, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 10, 56)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 10, 59)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 10, 56)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 10, 56)) +>createValidator2 : Symbol(createValidator2, Decl(isDeclarationVisibleNodeKinds.ts, 8, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 9, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 9, 56)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 9, 59)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 9, 56)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 9, 56)) return undefined; >undefined : Symbol(undefined) @@ -36,15 +35,15 @@ module schema { // union types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator3(schema: any): number | { new (data: T): T; } { ->createValidator3 : Symbol(createValidator3, Decl(isDeclarationVisibleNodeKinds.ts, 16, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 17, 38)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 17, 68)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 17, 71)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 17, 68)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 17, 68)) +>createValidator3 : Symbol(createValidator3, Decl(isDeclarationVisibleNodeKinds.ts, 15, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 16, 38)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 16, 68)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 16, 71)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 16, 68)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 16, 68)) return undefined; >undefined : Symbol(undefined) @@ -53,15 +52,15 @@ module schema { // Array types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator4(schema: any): { new (data: T): T; }[] { ->createValidator4 : Symbol(createValidator4, Decl(isDeclarationVisibleNodeKinds.ts, 23, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 24, 38)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 24, 59)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 24, 62)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 24, 59)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 24, 59)) +>createValidator4 : Symbol(createValidator4, Decl(isDeclarationVisibleNodeKinds.ts, 22, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 23, 38)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 23, 59)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 23, 62)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 23, 59)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 23, 59)) return undefined; >undefined : Symbol(undefined) @@ -71,15 +70,15 @@ module schema { // TypeLiterals module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator5(schema: any): { new (data: T): T } { ->createValidator5 : Symbol(createValidator5, Decl(isDeclarationVisibleNodeKinds.ts, 31, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 32, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 32, 58)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 32, 61)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 32, 58)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 32, 58)) +>createValidator5 : Symbol(createValidator5, Decl(isDeclarationVisibleNodeKinds.ts, 30, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 31, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 31, 58)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 31, 61)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 31, 58)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 31, 58)) return undefined; >undefined : Symbol(undefined) @@ -88,15 +87,15 @@ module schema { // Tuple types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator6(schema: any): [ new (data: T) => T, number] { ->createValidator6 : Symbol(createValidator6, Decl(isDeclarationVisibleNodeKinds.ts, 38, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 39, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 39, 58)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 39, 61)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 39, 58)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 39, 58)) +>createValidator6 : Symbol(createValidator6, Decl(isDeclarationVisibleNodeKinds.ts, 37, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 38, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 38, 58)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 38, 61)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 38, 58)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 38, 58)) return undefined; >undefined : Symbol(undefined) @@ -105,15 +104,15 @@ module schema { // Paren Types module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator7(schema: any): (new (data: T)=>T )[] { ->createValidator7 : Symbol(createValidator7, Decl(isDeclarationVisibleNodeKinds.ts, 45, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 46, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 46, 57)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 46, 60)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 46, 57)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 46, 57)) +>createValidator7 : Symbol(createValidator7, Decl(isDeclarationVisibleNodeKinds.ts, 44, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 45, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 45, 57)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 45, 60)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 45, 57)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 45, 57)) return undefined; >undefined : Symbol(undefined) @@ -122,16 +121,16 @@ module schema { // Type reference module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export function createValidator8(schema: any): Array<{ (data: T) : T}> { ->createValidator8 : Symbol(createValidator8, Decl(isDeclarationVisibleNodeKinds.ts, 52, 15)) ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 53, 37)) +>createValidator8 : Symbol(createValidator8, Decl(isDeclarationVisibleNodeKinds.ts, 51, 15)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 52, 37)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 53, 60)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 53, 63)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 53, 60)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 53, 60)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 52, 60)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 52, 63)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 52, 60)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 52, 60)) return undefined; >undefined : Symbol(undefined) @@ -140,29 +139,29 @@ module schema { module schema { ->schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 6, 1), Decl(isDeclarationVisibleNodeKinds.ts, 13, 1), Decl(isDeclarationVisibleNodeKinds.ts, 20, 1), Decl(isDeclarationVisibleNodeKinds.ts, 27, 1), Decl(isDeclarationVisibleNodeKinds.ts, 35, 1), Decl(isDeclarationVisibleNodeKinds.ts, 42, 1), Decl(isDeclarationVisibleNodeKinds.ts, 49, 1), Decl(isDeclarationVisibleNodeKinds.ts, 56, 1)) +>schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 0, 0), Decl(isDeclarationVisibleNodeKinds.ts, 5, 1), Decl(isDeclarationVisibleNodeKinds.ts, 12, 1), Decl(isDeclarationVisibleNodeKinds.ts, 19, 1), Decl(isDeclarationVisibleNodeKinds.ts, 26, 1), Decl(isDeclarationVisibleNodeKinds.ts, 34, 1), Decl(isDeclarationVisibleNodeKinds.ts, 41, 1), Decl(isDeclarationVisibleNodeKinds.ts, 48, 1), Decl(isDeclarationVisibleNodeKinds.ts, 55, 1)) export class T { ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 59, 15)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 58, 15)) get createValidator9(): (data: T) => T { ->createValidator9 : Symbol(T.createValidator9, Decl(isDeclarationVisibleNodeKinds.ts, 60, 20)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 61, 33)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 61, 36)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 61, 33)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 61, 33)) +>createValidator9 : Symbol(T.createValidator9, Decl(isDeclarationVisibleNodeKinds.ts, 59, 20)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 60, 33)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 60, 36)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 60, 33)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 60, 33)) return undefined; >undefined : Symbol(undefined) } set createValidator10(v: (data: T) => T) { ->createValidator10 : Symbol(T.createValidator10, Decl(isDeclarationVisibleNodeKinds.ts, 63, 9)) ->v : Symbol(v, Decl(isDeclarationVisibleNodeKinds.ts, 65, 30)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 65, 34)) ->data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 65, 37)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 65, 34)) ->T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 65, 34)) +>createValidator10 : Symbol(T.createValidator10, Decl(isDeclarationVisibleNodeKinds.ts, 62, 9)) +>v : Symbol(v, Decl(isDeclarationVisibleNodeKinds.ts, 64, 30)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 64, 34)) +>data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 64, 37)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 64, 34)) +>T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 64, 34)) } } } diff --git a/tests/baselines/reference/isDeclarationVisibleNodeKinds.types b/tests/baselines/reference/isDeclarationVisibleNodeKinds.types index b3fe8d684b72a..43d27f026e8c2 100644 --- a/tests/baselines/reference/isDeclarationVisibleNodeKinds.types +++ b/tests/baselines/reference/isDeclarationVisibleNodeKinds.types @@ -1,5 +1,4 @@ === tests/cases/compiler/isDeclarationVisibleNodeKinds.ts === - // Function types module schema { >schema : typeof schema diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt index e0eef7d892d0b..642e38cc6e0d7 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt @@ -1,9 +1,7 @@ -tests/cases/compiler/file1.ts(3,20): error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. +tests/cases/compiler/file1.ts(1,20): error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/file1.ts (1 errors) ==== - - declare const enum E { X = 1} ~ !!! error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.js b/tests/baselines/reference/isolatedModulesAmbientConstEnum.js index 6d9fc540d9a44..44b6e1c1d76f3 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.js +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.js @@ -1,6 +1,4 @@ //// [file1.ts] - - declare const enum E { X = 1} export var y; diff --git a/tests/baselines/reference/isolatedModulesDeclaration.errors.txt b/tests/baselines/reference/isolatedModulesDeclaration.errors.txt index 2997acd58ac5b..09a655c6da081 100644 --- a/tests/baselines/reference/isolatedModulesDeclaration.errors.txt +++ b/tests/baselines/reference/isolatedModulesDeclaration.errors.txt @@ -3,5 +3,4 @@ error TS5053: Option 'declaration' cannot be specified with option 'isolatedModu !!! error TS5053: Option 'declaration' cannot be specified with option 'isolatedModules'. ==== tests/cases/compiler/file1.ts (0 errors) ==== - export var x; \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesDeclaration.js b/tests/baselines/reference/isolatedModulesDeclaration.js index bb3e560a2f83e..9709118084f05 100644 --- a/tests/baselines/reference/isolatedModulesDeclaration.js +++ b/tests/baselines/reference/isolatedModulesDeclaration.js @@ -1,5 +1,4 @@ //// [file1.ts] - export var x; //// [file1.js] diff --git a/tests/baselines/reference/isolatedModulesImportExportElision.errors.txt b/tests/baselines/reference/isolatedModulesImportExportElision.errors.txt index 60d2ca987e438..c536f48763756 100644 --- a/tests/baselines/reference/isolatedModulesImportExportElision.errors.txt +++ b/tests/baselines/reference/isolatedModulesImportExportElision.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/file1.ts(2,17): error TS2307: Cannot find module 'module'. -tests/cases/compiler/file1.ts(3,18): error TS2307: Cannot find module 'module'. -tests/cases/compiler/file1.ts(4,21): error TS2307: Cannot find module 'module'. -tests/cases/compiler/file1.ts(12,18): error TS2307: Cannot find module 'module'. +tests/cases/compiler/file1.ts(1,17): error TS2307: Cannot find module 'module'. +tests/cases/compiler/file1.ts(2,18): error TS2307: Cannot find module 'module'. +tests/cases/compiler/file1.ts(3,21): error TS2307: Cannot find module 'module'. +tests/cases/compiler/file1.ts(11,18): error TS2307: Cannot find module 'module'. ==== tests/cases/compiler/file1.ts (4 errors) ==== - import {c} from "module" ~~~~~~~~ !!! error TS2307: Cannot find module 'module'. diff --git a/tests/baselines/reference/isolatedModulesImportExportElision.js b/tests/baselines/reference/isolatedModulesImportExportElision.js index 5aac4a6418671..a75fab450c22f 100644 --- a/tests/baselines/reference/isolatedModulesImportExportElision.js +++ b/tests/baselines/reference/isolatedModulesImportExportElision.js @@ -1,5 +1,4 @@ //// [file1.ts] - import {c} from "module" import {c2} from "module" import * as ns from "module" diff --git a/tests/baselines/reference/isolatedModulesNoEmitOnError.errors.txt b/tests/baselines/reference/isolatedModulesNoEmitOnError.errors.txt index 2579ffc4a9029..34ff251c16701 100644 --- a/tests/baselines/reference/isolatedModulesNoEmitOnError.errors.txt +++ b/tests/baselines/reference/isolatedModulesNoEmitOnError.errors.txt @@ -3,5 +3,4 @@ error TS5053: Option 'noEmitOnError' cannot be specified with option 'isolatedMo !!! error TS5053: Option 'noEmitOnError' cannot be specified with option 'isolatedModules'. ==== tests/cases/compiler/file1.ts (0 errors) ==== - export var x; \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesNoExternalModule.errors.txt b/tests/baselines/reference/isolatedModulesNoExternalModule.errors.txt index 29353b3284a58..6d0f12bb1aba3 100644 --- a/tests/baselines/reference/isolatedModulesNoExternalModule.errors.txt +++ b/tests/baselines/reference/isolatedModulesNoExternalModule.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/file1.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/file1.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/file1.ts (1 errors) ==== - var x; ~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesNoExternalModule.js b/tests/baselines/reference/isolatedModulesNoExternalModule.js index 52cdbaa140253..67545d5429ff1 100644 --- a/tests/baselines/reference/isolatedModulesNoExternalModule.js +++ b/tests/baselines/reference/isolatedModulesNoExternalModule.js @@ -1,5 +1,4 @@ //// [file1.ts] - var x; //// [file1.js] diff --git a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.js b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.js index 396fc5979115d..f48f53d93fce3 100644 --- a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.js +++ b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.js @@ -1,5 +1,4 @@ //// [file1.ts] - const enum E { X = 100 }; var e = E.X; export var x; diff --git a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.symbols b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.symbols index 4755208b21a31..5060bcc9e6fce 100644 --- a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.symbols +++ b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/file1.ts === - const enum E { X = 100 }; >E : Symbol(E, Decl(file1.ts, 0, 0)) ->X : Symbol(E.X, Decl(file1.ts, 1, 14)) +>X : Symbol(E.X, Decl(file1.ts, 0, 14)) var e = E.X; ->e : Symbol(e, Decl(file1.ts, 2, 3)) ->E.X : Symbol(E.X, Decl(file1.ts, 1, 14)) +>e : Symbol(e, Decl(file1.ts, 1, 3)) +>E.X : Symbol(E.X, Decl(file1.ts, 0, 14)) >E : Symbol(E, Decl(file1.ts, 0, 0)) ->X : Symbol(E.X, Decl(file1.ts, 1, 14)) +>X : Symbol(E.X, Decl(file1.ts, 0, 14)) export var x; ->x : Symbol(x, Decl(file1.ts, 3, 10)) +>x : Symbol(x, Decl(file1.ts, 2, 10)) diff --git a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.types b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.types index 0412a79c479bc..1ac53071e4c47 100644 --- a/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.types +++ b/tests/baselines/reference/isolatedModulesNonAmbientConstEnum.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - const enum E { X = 100 }; >E : E >X : E diff --git a/tests/baselines/reference/isolatedModulesOut.errors.txt b/tests/baselines/reference/isolatedModulesOut.errors.txt index 157ae98fcb359..5581ece62e689 100644 --- a/tests/baselines/reference/isolatedModulesOut.errors.txt +++ b/tests/baselines/reference/isolatedModulesOut.errors.txt @@ -1,11 +1,10 @@ error TS5053: Option 'out' cannot be specified with option 'isolatedModules'. -tests/cases/compiler/file1.ts(2,1): error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. +tests/cases/compiler/file1.ts(1,1): error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. tests/cases/compiler/file2.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. !!! error TS5053: Option 'out' cannot be specified with option 'isolatedModules'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - export var x; ~~~~~~~~~~~~~ !!! error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. diff --git a/tests/baselines/reference/isolatedModulesOut.js b/tests/baselines/reference/isolatedModulesOut.js index 44f319e103143..fe995704a460f 100644 --- a/tests/baselines/reference/isolatedModulesOut.js +++ b/tests/baselines/reference/isolatedModulesOut.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/isolatedModulesOut.ts] //// //// [file1.ts] - export var x; //// [file2.ts] var y; diff --git a/tests/baselines/reference/isolatedModulesPlainFile-AMD.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-AMD.errors.txt index 680070a73c843..d24da5e09ccfc 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-AMD.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-AMD.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-AMD.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-AMD.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-AMD.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-AMD.js b/tests/baselines/reference/isolatedModulesPlainFile-AMD.js index 1e45ee159d673..e4ec78ff904e6 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-AMD.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-AMD.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-AMD.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.errors.txt index d1f0ca3caadf8..43d18c54eb957 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-CommonJS.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-CommonJS.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-CommonJS.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.js b/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.js index 7026a7d9bed2d..f9047a65f0fe4 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-CommonJS.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-CommonJS.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesPlainFile-ES6.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-ES6.errors.txt index d46fce22fd783..56316072aff36 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-ES6.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-ES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-ES6.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-ES6.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-ES6.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-ES6.js b/tests/baselines/reference/isolatedModulesPlainFile-ES6.js index 245d3fe668fa0..446f8075bb14c 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-ES6.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-ES6.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-ES6.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesPlainFile-System.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-System.errors.txt index fe1a2f8001800..b1e2ba643fa5e 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-System.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-System.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-System.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-System.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-System.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-System.js b/tests/baselines/reference/isolatedModulesPlainFile-System.js index 43cad51d21354..3628a05db4ed8 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-System.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-System.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-System.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesPlainFile-UMD.errors.txt b/tests/baselines/reference/isolatedModulesPlainFile-UMD.errors.txt index 24c5c86f8f87c..29dfe4f67fbcf 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-UMD.errors.txt +++ b/tests/baselines/reference/isolatedModulesPlainFile-UMD.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/isolatedModulesPlainFile-UMD.ts(2,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. +tests/cases/compiler/isolatedModulesPlainFile-UMD.ts(1,1): error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/isolatedModulesPlainFile-UMD.ts (1 errors) ==== - declare function run(a: number): void; ~~~~~~~ !!! error TS1208: Cannot compile namespaces when the '--isolatedModules' flag is provided. diff --git a/tests/baselines/reference/isolatedModulesPlainFile-UMD.js b/tests/baselines/reference/isolatedModulesPlainFile-UMD.js index ece949b9100c6..46f576a90271d 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-UMD.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-UMD.js @@ -1,5 +1,4 @@ //// [isolatedModulesPlainFile-UMD.ts] - declare function run(a: number): void; run(1); diff --git a/tests/baselines/reference/isolatedModulesSourceMap.js b/tests/baselines/reference/isolatedModulesSourceMap.js index 02d394752d1d6..9e2869e24e508 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.js +++ b/tests/baselines/reference/isolatedModulesSourceMap.js @@ -1,5 +1,4 @@ //// [file1.ts] - export var x = 1; //// [file1.js] diff --git a/tests/baselines/reference/isolatedModulesSourceMap.js.map b/tests/baselines/reference/isolatedModulesSourceMap.js.map index 6c99c2737974b..139169df3154c 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.js.map +++ b/tests/baselines/reference/isolatedModulesSourceMap.js.map @@ -1,2 +1,2 @@ //// [file1.js.map] -{"version":3,"file":"file1.js","sourceRoot":"","sources":["file1.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC"} \ No newline at end of file +{"version":3,"file":"file1.js","sourceRoot":"","sources":["file1.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesSourceMap.sourcemap.txt b/tests/baselines/reference/isolatedModulesSourceMap.sourcemap.txt index a9b2d98d96730..a420d8f8e4fa9 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.sourcemap.txt +++ b/tests/baselines/reference/isolatedModulesSourceMap.sourcemap.txt @@ -18,8 +18,7 @@ sourceFile:file1.ts 7 > ^ 8 > ^ 9 > ^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >export 3 > 4 > var @@ -27,13 +26,13 @@ sourceFile:file1.ts 6 > = 7 > 1 8 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 7) Source(2, 7) + SourceIndex(0) -3 >Emitted(1, 8) Source(2, 8) + SourceIndex(0) -4 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) -5 >Emitted(1, 13) Source(2, 13) + SourceIndex(0) -6 >Emitted(1, 16) Source(2, 16) + SourceIndex(0) -7 >Emitted(1, 17) Source(2, 17) + SourceIndex(0) -8 >Emitted(1, 18) Source(2, 18) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 7) Source(1, 7) + SourceIndex(0) +3 >Emitted(1, 8) Source(1, 8) + SourceIndex(0) +4 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) +5 >Emitted(1, 13) Source(1, 13) + SourceIndex(0) +6 >Emitted(1, 16) Source(1, 16) + SourceIndex(0) +7 >Emitted(1, 17) Source(1, 17) + SourceIndex(0) +8 >Emitted(1, 18) Source(1, 18) + SourceIndex(0) --- >>>//# sourceMappingURL=file1.js.map \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesSourceMap.symbols b/tests/baselines/reference/isolatedModulesSourceMap.symbols index 2f2d16d8ad0dc..bfd3360315afb 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.symbols +++ b/tests/baselines/reference/isolatedModulesSourceMap.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export var x = 1; ->x : Symbol(x, Decl(file1.ts, 1, 10)) +>x : Symbol(x, Decl(file1.ts, 0, 10)) diff --git a/tests/baselines/reference/isolatedModulesSourceMap.types b/tests/baselines/reference/isolatedModulesSourceMap.types index 2ac7b1f2f65c4..4d09a6b72c45b 100644 --- a/tests/baselines/reference/isolatedModulesSourceMap.types +++ b/tests/baselines/reference/isolatedModulesSourceMap.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - export var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/isolatedModulesWithDeclarationFile.js b/tests/baselines/reference/isolatedModulesWithDeclarationFile.js index 42d091b610897..425423bd7e143 100644 --- a/tests/baselines/reference/isolatedModulesWithDeclarationFile.js +++ b/tests/baselines/reference/isolatedModulesWithDeclarationFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/isolatedModulesWithDeclarationFile.ts] //// //// [file1.d.ts] - declare function foo(): void; //// [file1.ts] diff --git a/tests/baselines/reference/isolatedModulesWithDeclarationFile.symbols b/tests/baselines/reference/isolatedModulesWithDeclarationFile.symbols index bccf8ce935778..a60e6b38a4103 100644 --- a/tests/baselines/reference/isolatedModulesWithDeclarationFile.symbols +++ b/tests/baselines/reference/isolatedModulesWithDeclarationFile.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.d.ts === - declare function foo(): void; >foo : Symbol(foo, Decl(file1.d.ts, 0, 0)) diff --git a/tests/baselines/reference/isolatedModulesWithDeclarationFile.types b/tests/baselines/reference/isolatedModulesWithDeclarationFile.types index 94adc5fa27e09..06eb150bb5ecd 100644 --- a/tests/baselines/reference/isolatedModulesWithDeclarationFile.types +++ b/tests/baselines/reference/isolatedModulesWithDeclarationFile.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.d.ts === - declare function foo(): void; >foo : () => void diff --git a/tests/baselines/reference/isomorphicMappedTypeInference.js b/tests/baselines/reference/isomorphicMappedTypeInference.js index 560c926877a92..9c4e8c9e9f140 100644 --- a/tests/baselines/reference/isomorphicMappedTypeInference.js +++ b/tests/baselines/reference/isomorphicMappedTypeInference.js @@ -1,5 +1,4 @@ //// [isomorphicMappedTypeInference.ts] - type Box = { value: T; } diff --git a/tests/baselines/reference/isomorphicMappedTypeInference.symbols b/tests/baselines/reference/isomorphicMappedTypeInference.symbols index 93ce825c35d26..6c638f442c8f8 100644 --- a/tests/baselines/reference/isomorphicMappedTypeInference.symbols +++ b/tests/baselines/reference/isomorphicMappedTypeInference.symbols @@ -1,420 +1,419 @@ === tests/cases/conformance/types/mapped/isomorphicMappedTypeInference.ts === - type Box = { >Box : Symbol(Box, Decl(isomorphicMappedTypeInference.ts, 0, 0)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 1, 9)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 0, 9)) value: T; ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 1, 9)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 0, 9)) } type Boxified = { ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 5, 14)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 4, 14)) [P in keyof T]: Box; ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 6, 5)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 5, 14)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 5, 5)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 4, 14)) >Box : Symbol(Box, Decl(isomorphicMappedTypeInference.ts, 0, 0)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 5, 14)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 6, 5)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 4, 14)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 5, 5)) } function box(x: T): Box { ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 9, 13)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 9, 16)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 9, 13)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 8, 13)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 8, 16)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 8, 13)) >Box : Symbol(Box, Decl(isomorphicMappedTypeInference.ts, 0, 0)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 9, 13)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 8, 13)) return { value: x }; ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 10, 12)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 9, 16)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 9, 12)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 8, 16)) } function unbox(x: Box): T { ->unbox : Symbol(unbox, Decl(isomorphicMappedTypeInference.ts, 11, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 13, 15)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 13, 18)) +>unbox : Symbol(unbox, Decl(isomorphicMappedTypeInference.ts, 10, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 12, 15)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 12, 18)) >Box : Symbol(Box, Decl(isomorphicMappedTypeInference.ts, 0, 0)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 13, 15)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 13, 15)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 12, 15)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 12, 15)) return x.value; ->x.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 13, 18)) ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) +>x.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 12, 18)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) } function boxify(obj: T): Boxified { ->boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 15, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 17, 16)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 17, 19)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 17, 16)) ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 17, 16)) +>boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 14, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 16, 16)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 16, 19)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 16, 16)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 16, 16)) let result = {} as Boxified; ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 18, 7)) ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 17, 16)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 17, 7)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 16, 16)) for (let k in obj) { ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 19, 12)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 17, 19)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 18, 12)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 16, 19)) result[k] = box(obj[k]); ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 18, 7)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 19, 12)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 17, 19)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 19, 12)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 17, 7)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 18, 12)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 16, 19)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 18, 12)) } return result; ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 18, 7)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 17, 7)) } function unboxify(obj: Boxified): T { ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 25, 18)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 25, 21)) ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 25, 18)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 25, 18)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 21)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18)) let result = {} as T; ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 26, 7)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 25, 18)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 25, 7)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18)) for (let k in obj) { ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 27, 12)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 25, 21)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 26, 12)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 21)) result[k] = unbox(obj[k]); ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 26, 7)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 27, 12)) ->unbox : Symbol(unbox, Decl(isomorphicMappedTypeInference.ts, 11, 1)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 25, 21)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 27, 12)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 25, 7)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 26, 12)) +>unbox : Symbol(unbox, Decl(isomorphicMappedTypeInference.ts, 10, 1)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 21)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 26, 12)) } return result; ->result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 26, 7)) +>result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 25, 7)) } function assignBoxified(obj: Boxified, values: T) { ->assignBoxified : Symbol(assignBoxified, Decl(isomorphicMappedTypeInference.ts, 31, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 33, 24)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 33, 27)) ->Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 3, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 33, 24)) ->values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 33, 44)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 33, 24)) +>assignBoxified : Symbol(assignBoxified, Decl(isomorphicMappedTypeInference.ts, 30, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 32, 24)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 32, 27)) +>Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 32, 24)) +>values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 32, 44)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 32, 24)) for (let k in values) { ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 34, 12)) ->values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 33, 44)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 33, 12)) +>values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 32, 44)) obj[k].value = values[k]; ->obj[k].value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 33, 27)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 34, 12)) ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) ->values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 33, 44)) ->k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 34, 12)) +>obj[k].value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 32, 27)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 33, 12)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) +>values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 32, 44)) +>k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 33, 12)) } } function f1() { ->f1 : Symbol(f1, Decl(isomorphicMappedTypeInference.ts, 37, 1)) +>f1 : Symbol(f1, Decl(isomorphicMappedTypeInference.ts, 36, 1)) let v = { ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 40, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 39, 7)) a: 42, ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 40, 13)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 39, 13)) b: "hello", ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 41, 14)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 40, 14)) c: true ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 42, 19)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 41, 19)) }; let b = boxify(v); ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 45, 7)) ->boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 15, 1)) ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 40, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 44, 7)) +>boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 14, 1)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 39, 7)) let x: number = b.a.value; ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 46, 7)) ->b.a.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 45, 7)) +>b.a.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) >b.a : Symbol(a) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 45, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 44, 7)) >a : Symbol(a) ->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 1, 15)) +>value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15)) } function f2() { ->f2 : Symbol(f2, Decl(isomorphicMappedTypeInference.ts, 47, 1)) +>f2 : Symbol(f2, Decl(isomorphicMappedTypeInference.ts, 46, 1)) let b = { ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 50, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 49, 7)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 50, 13)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 49, 13)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 51, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 50, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 52, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 51, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }; let v = unboxify(b); ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 55, 7)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 50, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 54, 7)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 49, 7)) let x: number = v.a; ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 56, 7)) ->v.a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 50, 13)) ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 55, 7)) ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 50, 13)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 55, 7)) +>v.a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 49, 13)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 54, 7)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 49, 13)) } function f3() { ->f3 : Symbol(f3, Decl(isomorphicMappedTypeInference.ts, 57, 1)) +>f3 : Symbol(f3, Decl(isomorphicMappedTypeInference.ts, 56, 1)) let b = { ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 60, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 59, 7)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 60, 13)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 59, 13)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 61, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 60, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 62, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 61, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }; assignBoxified(b, { c: false }); ->assignBoxified : Symbol(assignBoxified, Decl(isomorphicMappedTypeInference.ts, 31, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 60, 7)) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 65, 23)) +>assignBoxified : Symbol(assignBoxified, Decl(isomorphicMappedTypeInference.ts, 30, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 59, 7)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 64, 23)) } function f4() { ->f4 : Symbol(f4, Decl(isomorphicMappedTypeInference.ts, 66, 1)) +>f4 : Symbol(f4, Decl(isomorphicMappedTypeInference.ts, 65, 1)) let b = { ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 69, 13)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 68, 13)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 70, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 71, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 70, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }; b = boxify(unboxify(b)); ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) ->boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 15, 1)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) +>boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 14, 1)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) b = unboxify(boxify(b)); ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 15, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 69, 7)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>boxify : Symbol(boxify, Decl(isomorphicMappedTypeInference.ts, 14, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 68, 7)) } function makeRecord(obj: { [P in K]: T }) { ->makeRecord : Symbol(makeRecord, Decl(isomorphicMappedTypeInference.ts, 76, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 78, 20)) ->K : Symbol(K, Decl(isomorphicMappedTypeInference.ts, 78, 22)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 78, 41)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 78, 49)) ->K : Symbol(K, Decl(isomorphicMappedTypeInference.ts, 78, 22)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 78, 20)) +>makeRecord : Symbol(makeRecord, Decl(isomorphicMappedTypeInference.ts, 75, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 77, 20)) +>K : Symbol(K, Decl(isomorphicMappedTypeInference.ts, 77, 22)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 77, 41)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 77, 49)) +>K : Symbol(K, Decl(isomorphicMappedTypeInference.ts, 77, 22)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 77, 20)) return obj; ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 78, 41)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 77, 41)) } function f5(s: string) { ->f5 : Symbol(f5, Decl(isomorphicMappedTypeInference.ts, 80, 1)) ->s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 82, 12)) +>f5 : Symbol(f5, Decl(isomorphicMappedTypeInference.ts, 79, 1)) +>s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 81, 12)) let b = makeRecord({ ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 83, 7)) ->makeRecord : Symbol(makeRecord, Decl(isomorphicMappedTypeInference.ts, 76, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 82, 7)) +>makeRecord : Symbol(makeRecord, Decl(isomorphicMappedTypeInference.ts, 75, 1)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 83, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 82, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 84, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 83, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 85, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 84, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }); let v = unboxify(b); ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 88, 7)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 83, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 87, 7)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 82, 7)) let x: string | number | boolean = v.a; ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 89, 7)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 88, 7)) >v.a : Symbol(a) ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 88, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 87, 7)) >a : Symbol(a) } function makeDictionary(obj: { [x: string]: T }) { ->makeDictionary : Symbol(makeDictionary, Decl(isomorphicMappedTypeInference.ts, 90, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 92, 24)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 92, 27)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 92, 35)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 92, 24)) +>makeDictionary : Symbol(makeDictionary, Decl(isomorphicMappedTypeInference.ts, 89, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 91, 24)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 91, 27)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 91, 35)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 91, 24)) return obj; ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 92, 27)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 91, 27)) } function f6(s: string) { ->f6 : Symbol(f6, Decl(isomorphicMappedTypeInference.ts, 94, 1)) ->s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 96, 12)) +>f6 : Symbol(f6, Decl(isomorphicMappedTypeInference.ts, 93, 1)) +>s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 95, 12)) let b = makeDictionary({ ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 97, 7)) ->makeDictionary : Symbol(makeDictionary, Decl(isomorphicMappedTypeInference.ts, 90, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 96, 7)) +>makeDictionary : Symbol(makeDictionary, Decl(isomorphicMappedTypeInference.ts, 89, 1)) a: box(42), ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 97, 28)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 96, 28)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) b: box("hello"), ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 98, 19)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 97, 19)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) c: box(true) ->c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 99, 24)) ->box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 7, 1)) +>c : Symbol(c, Decl(isomorphicMappedTypeInference.ts, 98, 24)) +>box : Symbol(box, Decl(isomorphicMappedTypeInference.ts, 6, 1)) }); let v = unboxify(b); ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 102, 7)) ->unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 23, 1)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 97, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 101, 7)) +>unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 96, 7)) let x: string | number | boolean = v[s]; ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 103, 7)) ->v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 102, 7)) ->s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 96, 12)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 102, 7)) +>v : Symbol(v, Decl(isomorphicMappedTypeInference.ts, 101, 7)) +>s : Symbol(s, Decl(isomorphicMappedTypeInference.ts, 95, 12)) } declare function validate(obj: { [P in keyof T]?: T[P] }): T; ->validate : Symbol(validate, Decl(isomorphicMappedTypeInference.ts, 104, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 26)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 106, 29)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 106, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 26)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 26)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 106, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 26)) +>validate : Symbol(validate, Decl(isomorphicMappedTypeInference.ts, 103, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 105, 26)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 105, 29)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 105, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 105, 26)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 105, 26)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 105, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 105, 26)) declare function clone(obj: { readonly [P in keyof T]: T[P] }): T; ->clone : Symbol(clone, Decl(isomorphicMappedTypeInference.ts, 106, 64)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 23)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 107, 26)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 107, 43)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 23)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 23)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 107, 43)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 23)) +>clone : Symbol(clone, Decl(isomorphicMappedTypeInference.ts, 105, 64)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 23)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 106, 26)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 106, 43)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 23)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 23)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 106, 43)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 106, 23)) declare function validateAndClone(obj: { readonly [P in keyof T]?: T[P] }): T; ->validateAndClone : Symbol(validateAndClone, Decl(isomorphicMappedTypeInference.ts, 107, 69)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 108, 34)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 108, 37)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 108, 54)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 108, 34)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 108, 34)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 108, 54)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 108, 34)) +>validateAndClone : Symbol(validateAndClone, Decl(isomorphicMappedTypeInference.ts, 106, 69)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 34)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 107, 37)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 107, 54)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 34)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 34)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 107, 54)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 107, 34)) type Foo = { ->Foo : Symbol(Foo, Decl(isomorphicMappedTypeInference.ts, 108, 81)) +>Foo : Symbol(Foo, Decl(isomorphicMappedTypeInference.ts, 107, 81)) a?: number; ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 110, 12)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 109, 12)) readonly b: string; ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 111, 15)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 110, 15)) } function f10(foo: Foo) { ->f10 : Symbol(f10, Decl(isomorphicMappedTypeInference.ts, 113, 1)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 115, 13)) ->Foo : Symbol(Foo, Decl(isomorphicMappedTypeInference.ts, 108, 81)) +>f10 : Symbol(f10, Decl(isomorphicMappedTypeInference.ts, 112, 1)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 114, 13)) +>Foo : Symbol(Foo, Decl(isomorphicMappedTypeInference.ts, 107, 81)) let x = validate(foo); // { a: number, readonly b: string } ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 116, 7)) ->validate : Symbol(validate, Decl(isomorphicMappedTypeInference.ts, 104, 1)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 115, 13)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 115, 7)) +>validate : Symbol(validate, Decl(isomorphicMappedTypeInference.ts, 103, 1)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 114, 13)) let y = clone(foo); // { a?: number, b: string } ->y : Symbol(y, Decl(isomorphicMappedTypeInference.ts, 117, 7)) ->clone : Symbol(clone, Decl(isomorphicMappedTypeInference.ts, 106, 64)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 115, 13)) +>y : Symbol(y, Decl(isomorphicMappedTypeInference.ts, 116, 7)) +>clone : Symbol(clone, Decl(isomorphicMappedTypeInference.ts, 105, 64)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 114, 13)) let z = validateAndClone(foo); // { a: number, b: string } ->z : Symbol(z, Decl(isomorphicMappedTypeInference.ts, 118, 7)) ->validateAndClone : Symbol(validateAndClone, Decl(isomorphicMappedTypeInference.ts, 107, 69)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 115, 13)) +>z : Symbol(z, Decl(isomorphicMappedTypeInference.ts, 117, 7)) +>validateAndClone : Symbol(validateAndClone, Decl(isomorphicMappedTypeInference.ts, 106, 69)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 114, 13)) } // Repro from #12606 type Func = (...args: any[]) => T; ->Func : Symbol(Func, Decl(isomorphicMappedTypeInference.ts, 119, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) ->args : Symbol(args, Decl(isomorphicMappedTypeInference.ts, 123, 16)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) +>Func : Symbol(Func, Decl(isomorphicMappedTypeInference.ts, 118, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 122, 10)) +>args : Symbol(args, Decl(isomorphicMappedTypeInference.ts, 122, 16)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 122, 10)) type Spec = { ->Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 123, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 124, 10)) +>Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 122, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) [P in keyof T]: Func | Spec ; ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 125, 5)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 124, 10)) ->Func : Symbol(Func, Decl(isomorphicMappedTypeInference.ts, 119, 1)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 124, 10)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 125, 5)) ->Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 123, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 124, 10)) ->P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 125, 5)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 124, 5)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) +>Func : Symbol(Func, Decl(isomorphicMappedTypeInference.ts, 118, 1)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 124, 5)) +>Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 122, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 123, 10)) +>P : Symbol(P, Decl(isomorphicMappedTypeInference.ts, 124, 5)) }; @@ -424,66 +423,66 @@ type Spec = { * of calling its associated function with the supplied arguments. */ declare function applySpec(obj: Spec): (...args: any[]) => T; ->applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 126, 2)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 133, 27)) ->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 133, 30)) ->Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 123, 37)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 133, 27)) ->args : Symbol(args, Decl(isomorphicMappedTypeInference.ts, 133, 46)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 133, 27)) +>applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 125, 2)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 132, 27)) +>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 132, 30)) +>Spec : Symbol(Spec, Decl(isomorphicMappedTypeInference.ts, 122, 37)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 132, 27)) +>args : Symbol(args, Decl(isomorphicMappedTypeInference.ts, 132, 46)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 132, 27)) // Infers g1: (...args: any[]) => { sum: number, nested: { mul: string } } var g1 = applySpec({ ->g1 : Symbol(g1, Decl(isomorphicMappedTypeInference.ts, 136, 3)) ->applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 126, 2)) +>g1 : Symbol(g1, Decl(isomorphicMappedTypeInference.ts, 135, 3)) +>applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 125, 2)) sum: (a: any) => 3, ->sum : Symbol(sum, Decl(isomorphicMappedTypeInference.ts, 136, 20)) ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 137, 10)) +>sum : Symbol(sum, Decl(isomorphicMappedTypeInference.ts, 135, 20)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 136, 10)) nested: { ->nested : Symbol(nested, Decl(isomorphicMappedTypeInference.ts, 137, 23)) +>nested : Symbol(nested, Decl(isomorphicMappedTypeInference.ts, 136, 23)) mul: (b: any) => "n" ->mul : Symbol(mul, Decl(isomorphicMappedTypeInference.ts, 138, 13)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 139, 14)) +>mul : Symbol(mul, Decl(isomorphicMappedTypeInference.ts, 137, 13)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 138, 14)) } }); // Infers g2: (...args: any[]) => { foo: { bar: { baz: boolean } } } var g2 = applySpec({ foo: { bar: { baz: (x: any) => true } } }); ->g2 : Symbol(g2, Decl(isomorphicMappedTypeInference.ts, 144, 3)) ->applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 126, 2)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 144, 20)) ->bar : Symbol(bar, Decl(isomorphicMappedTypeInference.ts, 144, 27)) ->baz : Symbol(baz, Decl(isomorphicMappedTypeInference.ts, 144, 34)) ->x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 144, 41)) +>g2 : Symbol(g2, Decl(isomorphicMappedTypeInference.ts, 143, 3)) +>applySpec : Symbol(applySpec, Decl(isomorphicMappedTypeInference.ts, 125, 2)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 143, 20)) +>bar : Symbol(bar, Decl(isomorphicMappedTypeInference.ts, 143, 27)) +>baz : Symbol(baz, Decl(isomorphicMappedTypeInference.ts, 143, 34)) +>x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 143, 41)) // Repro from #12633 const foo = (object: T, partial: Partial) => object; ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 148, 5)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 148, 13)) ->object : Symbol(object, Decl(isomorphicMappedTypeInference.ts, 148, 16)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 148, 13)) ->partial : Symbol(partial, Decl(isomorphicMappedTypeInference.ts, 148, 26)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 147, 5)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 147, 13)) +>object : Symbol(object, Decl(isomorphicMappedTypeInference.ts, 147, 16)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 147, 13)) +>partial : Symbol(partial, Decl(isomorphicMappedTypeInference.ts, 147, 26)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 148, 13)) ->object : Symbol(object, Decl(isomorphicMappedTypeInference.ts, 148, 16)) +>T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 147, 13)) +>object : Symbol(object, Decl(isomorphicMappedTypeInference.ts, 147, 16)) let o = {a: 5, b: 7}; ->o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 149, 3)) ->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 149, 9)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 149, 14)) +>o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 148, 3)) +>a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 148, 9)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 148, 14)) foo(o, {b: 9}); ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 148, 5)) ->o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 149, 3)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 150, 8)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 147, 5)) +>o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 148, 3)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 149, 8)) o = foo(o, {b: 9}); ->o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 149, 3)) ->foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 148, 5)) ->o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 149, 3)) ->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 151, 12)) +>o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 148, 3)) +>foo : Symbol(foo, Decl(isomorphicMappedTypeInference.ts, 147, 5)) +>o : Symbol(o, Decl(isomorphicMappedTypeInference.ts, 148, 3)) +>b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 150, 12)) diff --git a/tests/baselines/reference/isomorphicMappedTypeInference.types b/tests/baselines/reference/isomorphicMappedTypeInference.types index ca20e06e11352..c3414f4601790 100644 --- a/tests/baselines/reference/isomorphicMappedTypeInference.types +++ b/tests/baselines/reference/isomorphicMappedTypeInference.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/isomorphicMappedTypeInference.ts === - type Box = { >Box : Box >T : T diff --git a/tests/baselines/reference/iteratorsAndStrictNullChecks.js b/tests/baselines/reference/iteratorsAndStrictNullChecks.js index 97007917de53f..23520a674d5f5 100644 --- a/tests/baselines/reference/iteratorsAndStrictNullChecks.js +++ b/tests/baselines/reference/iteratorsAndStrictNullChecks.js @@ -1,5 +1,4 @@ //// [iteratorsAndStrictNullChecks.ts] - // for..of for (const x of ["a", "b"]) { x.substring; diff --git a/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols b/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols index 8201a845a0fc8..fb75206a82577 100644 --- a/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols +++ b/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols @@ -1,25 +1,24 @@ === tests/cases/compiler/iteratorsAndStrictNullChecks.ts === - // for..of for (const x of ["a", "b"]) { ->x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 2, 10)) +>x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 1, 10)) x.substring; >x.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) ->x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 2, 10)) +>x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 1, 10)) >substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) } // Spread const xs = [1, 2, 3]; ->xs : Symbol(xs, Decl(iteratorsAndStrictNullChecks.ts, 7, 5)) +>xs : Symbol(xs, Decl(iteratorsAndStrictNullChecks.ts, 6, 5)) const ys = [4, 5]; ->ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 8, 5)) +>ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 7, 5)) xs.push(...ys); >xs.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->xs : Symbol(xs, Decl(iteratorsAndStrictNullChecks.ts, 7, 5)) +>xs : Symbol(xs, Decl(iteratorsAndStrictNullChecks.ts, 6, 5)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 8, 5)) +>ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 7, 5)) diff --git a/tests/baselines/reference/iteratorsAndStrictNullChecks.types b/tests/baselines/reference/iteratorsAndStrictNullChecks.types index 43efed86ed47d..efb5c1f97f2bc 100644 --- a/tests/baselines/reference/iteratorsAndStrictNullChecks.types +++ b/tests/baselines/reference/iteratorsAndStrictNullChecks.types @@ -1,5 +1,4 @@ === tests/cases/compiler/iteratorsAndStrictNullChecks.ts === - // for..of for (const x of ["a", "b"]) { >x : string diff --git a/tests/baselines/reference/jsDocTags.baseline b/tests/baselines/reference/jsDocTags.baseline new file mode 100644 index 0000000000000..4140fa6bfca29 --- /dev/null +++ b/tests/baselines/reference/jsDocTags.baseline @@ -0,0 +1,671 @@ +[ + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 981 + }, + "quickInfo": { + "kind": "constructor", + "kindModifiers": "", + "textSpan": { + "start": 981, + "length": 3 + }, + "displayParts": [ + { + "text": "constructor", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + }, + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "value", + "kind": "parameterName" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "number", + "kind": "keyword" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + } + ], + "documentation": [ + { + "text": "This is the constructor.", + "kind": "text" + } + ], + "tags": [ + { + "name": "myjsdoctag", + "text": "this is a comment" + } + ] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 985 + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 989 + }, + "quickInfo": { + "kind": "class", + "kindModifiers": "", + "textSpan": { + "start": 989, + "length": 3 + }, + "displayParts": [ + { + "text": "class", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + } + ], + "documentation": [ + { + "text": "This is class Foo.", + "kind": "text" + } + ], + "tags": [ + { + "name": "mytag", + "text": "comment1 comment2" + } + ] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 993 + }, + "quickInfo": { + "kind": "method", + "kindModifiers": "static", + "textSpan": { + "start": 993, + "length": 7 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "method", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "method1", + "kind": "methodName" + }, + { + "text": "(", + "kind": "punctuation" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "void", + "kind": "keyword" + } + ], + "documentation": [ + { + "text": "method1 documentation", + "kind": "text" + } + ], + "tags": [ + { + "name": "mytag", + "text": "comment1 comment2" + } + ] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1001 + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1008 + }, + "quickInfo": { + "kind": "method", + "kindModifiers": "", + "textSpan": { + "start": 1008, + "length": 7 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "method", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "method2", + "kind": "methodName" + }, + { + "text": "(", + "kind": "punctuation" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "void", + "kind": "keyword" + } + ], + "documentation": [], + "tags": [ + { + "name": "mytag", + "text": "" + } + ] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1016 + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1023 + }, + "quickInfo": { + "kind": "method", + "kindModifiers": "", + "textSpan": { + "start": 1023, + "length": 7 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "method", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "method3", + "kind": "methodName" + }, + { + "text": "(", + "kind": "punctuation" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "number", + "kind": "keyword" + } + ], + "documentation": [], + "tags": [] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1031 + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1038 + }, + "quickInfo": { + "kind": "method", + "kindModifiers": "", + "textSpan": { + "start": 1038, + "length": 7 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "method", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "method4", + "kind": "methodName" + }, + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "foo", + "kind": "parameterName" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "string", + "kind": "keyword" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "number", + "kind": "keyword" + } + ], + "documentation": [], + "tags": [ + { + "name": "mytag", + "text": "" + } + ] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1053 + }, + "quickInfo": { + "kind": "property", + "kindModifiers": "", + "textSpan": { + "start": 1053, + "length": 9 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "property", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "property1", + "kind": "propertyName" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "string", + "kind": "keyword" + } + ], + "documentation": [], + "tags": [ + { + "name": "mytag", + "text": "comment1 comment2" + } + ] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1068 + }, + "quickInfo": { + "kind": "property", + "kindModifiers": "", + "textSpan": { + "start": 1068, + "length": 9 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "property", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "property2", + "kind": "propertyName" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "number", + "kind": "keyword" + } + ], + "documentation": [], + "tags": [ + { + "name": "mytag1", + "text": "some comments\nsome more comments about mytag1" + }, + { + "name": "mytag2", + "text": "here all the comments are on a new line" + }, + { + "name": "mytag3", + "text": "" + }, + { + "name": "mytag", + "text": "" + } + ] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1083 + }, + "quickInfo": { + "kind": "method", + "kindModifiers": "", + "textSpan": { + "start": 1083, + "length": 7 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "method", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "Foo", + "kind": "className" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "method5", + "kind": "methodName" + }, + { + "text": "(", + "kind": "punctuation" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": ":", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "void", + "kind": "keyword" + } + ], + "documentation": [], + "tags": [ + { + "name": "mytag", + "text": "" + } + ] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/jsDocTags.ts", + "position": 1104 + }, + "quickInfo": { + "kind": "", + "kindModifiers": "", + "textSpan": { + "start": 1098, + "length": 6 + }, + "displayParts": [ + { + "text": "any", + "kind": "keyword" + } + ] + } + } +] \ No newline at end of file diff --git a/tests/baselines/reference/jsDocTypes.js b/tests/baselines/reference/jsDocTypes.js index a6df2f361c667..aab32275f72de 100644 --- a/tests/baselines/reference/jsDocTypes.js +++ b/tests/baselines/reference/jsDocTypes.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/salsa/jsDocTypes.ts] //// //// [a.js] - /** @type {String} */ var S; diff --git a/tests/baselines/reference/jsDocTypes.symbols b/tests/baselines/reference/jsDocTypes.symbols index 9bde032cb443a..eb795295ea05b 100644 --- a/tests/baselines/reference/jsDocTypes.symbols +++ b/tests/baselines/reference/jsDocTypes.symbols @@ -1,133 +1,132 @@ === tests/cases/conformance/salsa/a.js === - /** @type {String} */ var S; ->S : Symbol(S, Decl(a.js, 2, 3), Decl(b.ts, 0, 3)) +>S : Symbol(S, Decl(a.js, 1, 3), Decl(b.ts, 0, 3)) /** @type {string} */ var s; ->s : Symbol(s, Decl(a.js, 5, 3), Decl(b.ts, 1, 3)) +>s : Symbol(s, Decl(a.js, 4, 3), Decl(b.ts, 1, 3)) /** @type {Number} */ var N; ->N : Symbol(N, Decl(a.js, 8, 3), Decl(b.ts, 2, 3)) +>N : Symbol(N, Decl(a.js, 7, 3), Decl(b.ts, 2, 3)) /** @type {number} */ var n; ->n : Symbol(n, Decl(a.js, 11, 3), Decl(b.ts, 3, 3)) +>n : Symbol(n, Decl(a.js, 10, 3), Decl(b.ts, 3, 3)) /** @type {Boolean} */ var B; ->B : Symbol(B, Decl(a.js, 14, 3), Decl(b.ts, 4, 3)) +>B : Symbol(B, Decl(a.js, 13, 3), Decl(b.ts, 4, 3)) /** @type {boolean} */ var b; ->b : Symbol(b, Decl(a.js, 17, 3), Decl(b.ts, 5, 3)) +>b : Symbol(b, Decl(a.js, 16, 3), Decl(b.ts, 5, 3)) /** @type {Void} */ var V; ->V : Symbol(V, Decl(a.js, 20, 3), Decl(b.ts, 6, 3)) +>V : Symbol(V, Decl(a.js, 19, 3), Decl(b.ts, 6, 3)) /** @type {void} */ var v; ->v : Symbol(v, Decl(a.js, 23, 3), Decl(b.ts, 7, 3)) +>v : Symbol(v, Decl(a.js, 22, 3), Decl(b.ts, 7, 3)) /** @type {Undefined} */ var U; ->U : Symbol(U, Decl(a.js, 26, 3), Decl(b.ts, 8, 3)) +>U : Symbol(U, Decl(a.js, 25, 3), Decl(b.ts, 8, 3)) /** @type {undefined} */ var u; ->u : Symbol(u, Decl(a.js, 29, 3), Decl(b.ts, 9, 3)) +>u : Symbol(u, Decl(a.js, 28, 3), Decl(b.ts, 9, 3)) /** @type {Null} */ var Nl; ->Nl : Symbol(Nl, Decl(a.js, 32, 3), Decl(b.ts, 10, 3)) +>Nl : Symbol(Nl, Decl(a.js, 31, 3), Decl(b.ts, 10, 3)) /** @type {null} */ var nl; ->nl : Symbol(nl, Decl(a.js, 35, 3), Decl(b.ts, 11, 3)) +>nl : Symbol(nl, Decl(a.js, 34, 3), Decl(b.ts, 11, 3)) /** @type {Array} */ var A; ->A : Symbol(A, Decl(a.js, 38, 3), Decl(b.ts, 12, 3)) +>A : Symbol(A, Decl(a.js, 37, 3), Decl(b.ts, 12, 3)) /** @type {array} */ var a; ->a : Symbol(a, Decl(a.js, 41, 3), Decl(b.ts, 13, 3)) +>a : Symbol(a, Decl(a.js, 40, 3), Decl(b.ts, 13, 3)) /** @type {Promise} */ var P; ->P : Symbol(P, Decl(a.js, 44, 3), Decl(b.ts, 14, 3)) +>P : Symbol(P, Decl(a.js, 43, 3), Decl(b.ts, 14, 3)) /** @type {promise} */ var p; ->p : Symbol(p, Decl(a.js, 47, 3), Decl(b.ts, 15, 3)) +>p : Symbol(p, Decl(a.js, 46, 3), Decl(b.ts, 15, 3)) /** @type {?number} */ var nullable; ->nullable : Symbol(nullable, Decl(a.js, 50, 3), Decl(b.ts, 16, 3)) +>nullable : Symbol(nullable, Decl(a.js, 49, 3), Decl(b.ts, 16, 3)) /** @type {Object} */ var Obj; ->Obj : Symbol(Obj, Decl(a.js, 53, 3), Decl(b.ts, 17, 3)) +>Obj : Symbol(Obj, Decl(a.js, 52, 3), Decl(b.ts, 17, 3)) === tests/cases/conformance/salsa/b.ts === var S: string; ->S : Symbol(S, Decl(a.js, 2, 3), Decl(b.ts, 0, 3)) +>S : Symbol(S, Decl(a.js, 1, 3), Decl(b.ts, 0, 3)) var s: string; ->s : Symbol(s, Decl(a.js, 5, 3), Decl(b.ts, 1, 3)) +>s : Symbol(s, Decl(a.js, 4, 3), Decl(b.ts, 1, 3)) var N: number; ->N : Symbol(N, Decl(a.js, 8, 3), Decl(b.ts, 2, 3)) +>N : Symbol(N, Decl(a.js, 7, 3), Decl(b.ts, 2, 3)) var n: number ->n : Symbol(n, Decl(a.js, 11, 3), Decl(b.ts, 3, 3)) +>n : Symbol(n, Decl(a.js, 10, 3), Decl(b.ts, 3, 3)) var B: boolean; ->B : Symbol(B, Decl(a.js, 14, 3), Decl(b.ts, 4, 3)) +>B : Symbol(B, Decl(a.js, 13, 3), Decl(b.ts, 4, 3)) var b: boolean; ->b : Symbol(b, Decl(a.js, 17, 3), Decl(b.ts, 5, 3)) +>b : Symbol(b, Decl(a.js, 16, 3), Decl(b.ts, 5, 3)) var V :void; ->V : Symbol(V, Decl(a.js, 20, 3), Decl(b.ts, 6, 3)) +>V : Symbol(V, Decl(a.js, 19, 3), Decl(b.ts, 6, 3)) var v: void; ->v : Symbol(v, Decl(a.js, 23, 3), Decl(b.ts, 7, 3)) +>v : Symbol(v, Decl(a.js, 22, 3), Decl(b.ts, 7, 3)) var U: undefined; ->U : Symbol(U, Decl(a.js, 26, 3), Decl(b.ts, 8, 3)) +>U : Symbol(U, Decl(a.js, 25, 3), Decl(b.ts, 8, 3)) var u: undefined; ->u : Symbol(u, Decl(a.js, 29, 3), Decl(b.ts, 9, 3)) +>u : Symbol(u, Decl(a.js, 28, 3), Decl(b.ts, 9, 3)) var Nl: null; ->Nl : Symbol(Nl, Decl(a.js, 32, 3), Decl(b.ts, 10, 3)) +>Nl : Symbol(Nl, Decl(a.js, 31, 3), Decl(b.ts, 10, 3)) var nl: null; ->nl : Symbol(nl, Decl(a.js, 35, 3), Decl(b.ts, 11, 3)) +>nl : Symbol(nl, Decl(a.js, 34, 3), Decl(b.ts, 11, 3)) var A: any[]; ->A : Symbol(A, Decl(a.js, 38, 3), Decl(b.ts, 12, 3)) +>A : Symbol(A, Decl(a.js, 37, 3), Decl(b.ts, 12, 3)) var a: any[]; ->a : Symbol(a, Decl(a.js, 41, 3), Decl(b.ts, 13, 3)) +>a : Symbol(a, Decl(a.js, 40, 3), Decl(b.ts, 13, 3)) var P: Promise; ->P : Symbol(P, Decl(a.js, 44, 3), Decl(b.ts, 14, 3)) +>P : Symbol(P, Decl(a.js, 43, 3), Decl(b.ts, 14, 3)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --)) var p: Promise; ->p : Symbol(p, Decl(a.js, 47, 3), Decl(b.ts, 15, 3)) +>p : Symbol(p, Decl(a.js, 46, 3), Decl(b.ts, 15, 3)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --)) var nullable: number | null; ->nullable : Symbol(nullable, Decl(a.js, 50, 3), Decl(b.ts, 16, 3)) +>nullable : Symbol(nullable, Decl(a.js, 49, 3), Decl(b.ts, 16, 3)) var Obj: any; ->Obj : Symbol(Obj, Decl(a.js, 53, 3), Decl(b.ts, 17, 3)) +>Obj : Symbol(Obj, Decl(a.js, 52, 3), Decl(b.ts, 17, 3)) diff --git a/tests/baselines/reference/jsDocTypes.types b/tests/baselines/reference/jsDocTypes.types index c0214edf62786..116e9f0a24520 100644 --- a/tests/baselines/reference/jsDocTypes.types +++ b/tests/baselines/reference/jsDocTypes.types @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/a.js === - /** @type {String} */ var S; >S : string diff --git a/tests/baselines/reference/jsFileClassPropertyType.errors.txt b/tests/baselines/reference/jsFileClassPropertyType.errors.txt index f37671757104e..72d11da977804 100644 --- a/tests/baselines/reference/jsFileClassPropertyType.errors.txt +++ b/tests/baselines/reference/jsFileClassPropertyType.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/bar.ts(2,1): error TS2322: Type '"string"' is not assignable to type 'number'. +tests/cases/compiler/bar.ts(1,1): error TS2322: Type '"string"' is not assignable to type 'number'. ==== tests/cases/compiler/foo.js (0 errors) ==== - class C { constructor () { this.p = 0; @@ -10,7 +9,6 @@ tests/cases/compiler/bar.ts(2,1): error TS2322: Type '"string"' is not assignabl } ==== tests/cases/compiler/bar.ts (1 errors) ==== - (new C()).p = "string"; ~~~~~~~~~~~ !!! error TS2322: Type '"string"' is not assignable to type 'number'. diff --git a/tests/baselines/reference/jsFileClassPropertyType2.errors.txt b/tests/baselines/reference/jsFileClassPropertyType2.errors.txt index d0d138f7f4833..e033ed3874e3d 100644 --- a/tests/baselines/reference/jsFileClassPropertyType2.errors.txt +++ b/tests/baselines/reference/jsFileClassPropertyType2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/bar.ts(2,18): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'. +tests/cases/compiler/bar.ts(1,18): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'. ==== tests/cases/compiler/foo.js (0 errors) ==== - class C { constructor() { /** @type {number[]}*/ @@ -11,7 +10,6 @@ tests/cases/compiler/bar.ts(2,18): error TS2345: Argument of type '"string"' is } ==== tests/cases/compiler/bar.ts (1 errors) ==== - (new C()).p.push("string"); ~~~~~~~~ !!! error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'. diff --git a/tests/baselines/reference/jsFileClassPropertyType3.errors.txt b/tests/baselines/reference/jsFileClassPropertyType3.errors.txt index bf225095b01ca..1035d92ea1b58 100644 --- a/tests/baselines/reference/jsFileClassPropertyType3.errors.txt +++ b/tests/baselines/reference/jsFileClassPropertyType3.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/bar.ts(2,1): error TS2322: Type '"string"' is not assignable to type 'number'. +tests/cases/compiler/bar.ts(1,1): error TS2322: Type '"string"' is not assignable to type 'number'. ==== tests/cases/compiler/foo.js (0 errors) ==== - class C { constructor() { if (cond) { @@ -15,7 +14,6 @@ tests/cases/compiler/bar.ts(2,1): error TS2322: Type '"string"' is not assignabl } ==== tests/cases/compiler/bar.ts (1 errors) ==== - (new C()).p = "string"; // Error ~~~~~~~~~~~ !!! error TS2322: Type '"string"' is not assignable to type 'number'. diff --git a/tests/baselines/reference/jsFileClassSelfReferencedProperty.symbols b/tests/baselines/reference/jsFileClassSelfReferencedProperty.symbols index 2d9626897bfd5..a6d078dbf741b 100644 --- a/tests/baselines/reference/jsFileClassSelfReferencedProperty.symbols +++ b/tests/baselines/reference/jsFileClassSelfReferencedProperty.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/foo.js === - export class StackOverflowTest { >StackOverflowTest : Symbol(StackOverflowTest, Decl(foo.js, 0, 0)) constructor () { this.testStackOverflow = this.testStackOverflow.bind(this) ->this.testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 2, 18)) +>this.testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 1, 18)) >this : Symbol(StackOverflowTest, Decl(foo.js, 0, 0)) ->testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 2, 18)) ->this.testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 2, 18)) +>testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 1, 18)) +>this.testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 1, 18)) >this : Symbol(StackOverflowTest, Decl(foo.js, 0, 0)) ->testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 2, 18)) +>testStackOverflow : Symbol(StackOverflowTest.testStackOverflow, Decl(foo.js, 1, 18)) >this : Symbol(StackOverflowTest, Decl(foo.js, 0, 0)) } } diff --git a/tests/baselines/reference/jsFileClassSelfReferencedProperty.types b/tests/baselines/reference/jsFileClassSelfReferencedProperty.types index 44344ac147204..204eee67c9707 100644 --- a/tests/baselines/reference/jsFileClassSelfReferencedProperty.types +++ b/tests/baselines/reference/jsFileClassSelfReferencedProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/foo.js === - export class StackOverflowTest { >StackOverflowTest : StackOverflowTest diff --git a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.js b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.js index 32b10dafad30c..0e7ff45f16c07 100644 --- a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.js +++ b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.js @@ -1,5 +1,4 @@ //// [a.js] - class c { method(a) { let x = a => this.method(a); diff --git a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.symbols b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.symbols index 0f6ba8442907c..a927a2a2ecbe0 100644 --- a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.symbols +++ b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/a.js === - class c { >c : Symbol(c, Decl(a.js, 0, 0)) method(a) { ->method : Symbol(c.method, Decl(a.js, 1, 9)) ->a : Symbol(a, Decl(a.js, 2, 11)) +>method : Symbol(c.method, Decl(a.js, 0, 9)) +>a : Symbol(a, Decl(a.js, 1, 11)) let x = a => this.method(a); ->x : Symbol(x, Decl(a.js, 3, 11)) ->a : Symbol(a, Decl(a.js, 3, 15)) ->this.method : Symbol(c.method, Decl(a.js, 1, 9)) +>x : Symbol(x, Decl(a.js, 2, 11)) +>a : Symbol(a, Decl(a.js, 2, 15)) +>this.method : Symbol(c.method, Decl(a.js, 0, 9)) >this : Symbol(c, Decl(a.js, 0, 0)) ->method : Symbol(c.method, Decl(a.js, 1, 9)) ->a : Symbol(a, Decl(a.js, 3, 15)) +>method : Symbol(c.method, Decl(a.js, 0, 9)) +>a : Symbol(a, Decl(a.js, 2, 15)) } } diff --git a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.types b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.types index f429cc8851687..5ad6841b77838 100644 --- a/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.types +++ b/tests/baselines/reference/jsFileCompilationClassMethodContainingArrowFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - class c { >c : c diff --git a/tests/baselines/reference/jsFileCompilationExternalPackageError.symbols b/tests/baselines/reference/jsFileCompilationExternalPackageError.symbols index fcb678c3e6c25..7663b2fcedf9b 100644 --- a/tests/baselines/reference/jsFileCompilationExternalPackageError.symbols +++ b/tests/baselines/reference/jsFileCompilationExternalPackageError.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/moduleA/a.js === - import {a} from "b"; ->a : Symbol(a, Decl(a.js, 1, 8)) +>a : Symbol(a, Decl(a.js, 0, 8)) a++; ->a : Symbol(a, Decl(a.js, 1, 8)) +>a : Symbol(a, Decl(a.js, 0, 8)) import {c} from "c"; ->c : Symbol(c, Decl(a.js, 3, 8)) +>c : Symbol(c, Decl(a.js, 2, 8)) c++; ->c : Symbol(c, Decl(a.js, 3, 8)) +>c : Symbol(c, Decl(a.js, 2, 8)) === tests/cases/compiler/node_modules/b.ts === var a = 10; diff --git a/tests/baselines/reference/jsFileCompilationExternalPackageError.types b/tests/baselines/reference/jsFileCompilationExternalPackageError.types index d3a696d7bfe9b..c41a24fcffdf2 100644 --- a/tests/baselines/reference/jsFileCompilationExternalPackageError.types +++ b/tests/baselines/reference/jsFileCompilationExternalPackageError.types @@ -1,5 +1,4 @@ === tests/cases/compiler/moduleA/a.js === - import {a} from "b"; >a : any diff --git a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.js b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.js index a87dad3c91400..bf3baf3de379d 100644 --- a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.js +++ b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.js @@ -1,5 +1,4 @@ //// [a.js] - function foo(a) { for (let a = 0; a < 10; a++) { // do something diff --git a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.symbols b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.symbols index 6b0934c659104..5c260013632fb 100644 --- a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.symbols +++ b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/a.js === - function foo(a) { >foo : Symbol(foo, Decl(a.js, 0, 0)) ->a : Symbol(a, Decl(a.js, 1, 13)) +>a : Symbol(a, Decl(a.js, 0, 13)) for (let a = 0; a < 10; a++) { ->a : Symbol(a, Decl(a.js, 2, 12)) ->a : Symbol(a, Decl(a.js, 2, 12)) ->a : Symbol(a, Decl(a.js, 2, 12)) +>a : Symbol(a, Decl(a.js, 1, 12)) +>a : Symbol(a, Decl(a.js, 1, 12)) +>a : Symbol(a, Decl(a.js, 1, 12)) // do something } diff --git a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.types b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.types index 3cac906f5d73f..15fa6c51087ca 100644 --- a/tests/baselines/reference/jsFileCompilationLetBeingRenamed.types +++ b/tests/baselines/reference/jsFileCompilationLetBeingRenamed.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - function foo(a) { >foo : (a: any) => void >a : any diff --git a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.js b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.js index 088b40e97ad74..acc590418e980 100644 --- a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.js +++ b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.js @@ -1,5 +1,4 @@ //// [_apply.js] - /** * A faster alternative to `Function#apply`, this function invokes `func` * with the `this` binding of `thisArg` and the arguments of `args`. diff --git a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.symbols b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.symbols index f21653d475b37..e7589f6ce5571 100644 --- a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.symbols +++ b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/_apply.js === - /** * A faster alternative to `Function#apply`, this function invokes `func` * with the `this` binding of `thisArg` and the arguments of `args`. @@ -12,55 +11,55 @@ */ function apply(func, thisArg, args) { >apply : Symbol(apply, Decl(_apply.js, 0, 0)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) var length = args.length; ->length : Symbol(length, Decl(_apply.js, 12, 7)) +>length : Symbol(length, Decl(_apply.js, 11, 7)) >args.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) >length : Symbol(Array.length, Decl(lib.d.ts, --, --)) switch (length) { ->length : Symbol(length, Decl(_apply.js, 12, 7)) +>length : Symbol(length, Decl(_apply.js, 11, 7)) case 0: return func.call(thisArg); >func.call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) case 1: return func.call(thisArg, args[0]); >func.call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) case 2: return func.call(thisArg, args[0], args[1]); >func.call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) case 3: return func.call(thisArg, args[0], args[1], args[2]); >func.call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >call : Symbol(Function.call, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) } return func.apply(thisArg, args); >func.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) ->func : Symbol(func, Decl(_apply.js, 11, 15)) +>func : Symbol(func, Decl(_apply.js, 10, 15)) >apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) ->thisArg : Symbol(thisArg, Decl(_apply.js, 11, 20)) ->args : Symbol(args, Decl(_apply.js, 11, 29)) +>thisArg : Symbol(thisArg, Decl(_apply.js, 10, 20)) +>args : Symbol(args, Decl(_apply.js, 10, 29)) } export default apply; diff --git a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types index f40e9164c3839..66e3da3e67f93 100644 --- a/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types +++ b/tests/baselines/reference/jsFileCompilationRestParamJsDocFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/_apply.js === - /** * A faster alternative to `Function#apply`, this function invokes `func` * with the `this` binding of `thisArg` and the arguments of `args`. diff --git a/tests/baselines/reference/jsFileCompilationShortHandProperty.js b/tests/baselines/reference/jsFileCompilationShortHandProperty.js index 1dc269146a63d..7d3cab85f4dd1 100644 --- a/tests/baselines/reference/jsFileCompilationShortHandProperty.js +++ b/tests/baselines/reference/jsFileCompilationShortHandProperty.js @@ -1,5 +1,4 @@ //// [a.js] - function foo() { var a = 10; var b = "Hello"; diff --git a/tests/baselines/reference/jsFileCompilationShortHandProperty.symbols b/tests/baselines/reference/jsFileCompilationShortHandProperty.symbols index fb42d121c8055..be2502e0f220c 100644 --- a/tests/baselines/reference/jsFileCompilationShortHandProperty.symbols +++ b/tests/baselines/reference/jsFileCompilationShortHandProperty.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/a.js === - function foo() { >foo : Symbol(foo, Decl(a.js, 0, 0)) var a = 10; ->a : Symbol(a, Decl(a.js, 2, 7)) +>a : Symbol(a, Decl(a.js, 1, 7)) var b = "Hello"; ->b : Symbol(b, Decl(a.js, 3, 7)) +>b : Symbol(b, Decl(a.js, 2, 7)) return { a, ->a : Symbol(a, Decl(a.js, 4, 12)) +>a : Symbol(a, Decl(a.js, 3, 12)) b ->b : Symbol(b, Decl(a.js, 5, 10)) +>b : Symbol(b, Decl(a.js, 4, 10)) }; } diff --git a/tests/baselines/reference/jsFileCompilationShortHandProperty.types b/tests/baselines/reference/jsFileCompilationShortHandProperty.types index ab8892b4661d3..d929247ca332c 100644 --- a/tests/baselines/reference/jsFileCompilationShortHandProperty.types +++ b/tests/baselines/reference/jsFileCompilationShortHandProperty.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - function foo() { >foo : () => { [x: string]: any; a: number; b: string; } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.errors.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.errors.txt index 84dfd78e6a342..f9d88bd272751 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.errors.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.errors.txt @@ -7,7 +7,6 @@ error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. Th !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. !!! error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts', '.js', '.jsx'. ==== tests/cases/compiler/a.ts (0 errors) ==== - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js index 8e70b464c2fd5..6f2eaeb737914 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsFileCompilationWithMapFileAsJs.ts] //// //// [a.ts] - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js.map b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js.map index d56cd75b1c2d9..5c7c4536a1632 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js.map +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.js.map @@ -1,2 +1,2 @@ //// [a.js.map] -{"version":3,"file":"a.js","sourceRoot":"","sources":["a.ts"],"names":[],"mappings":"AACA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} \ No newline at end of file +{"version":3,"file":"a.js","sourceRoot":"","sources":["a.ts"],"names":[],"mappings":"AAAA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.sourcemap.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.sourcemap.txt index d8c66a888b38d..01e7315964192 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.sourcemap.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJs.sourcemap.txt @@ -11,15 +11,14 @@ sourceFile:a.ts >>>var c = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function c() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -28,16 +27,16 @@ sourceFile:a.ts 1->class c { > 2 > } -1->Emitted(3, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(3, 6) Source(3, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(3, 6) Source(2, 2) + SourceIndex(0) --- >>> return c; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(4, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(4, 13) Source(3, 2) + SourceIndex(0) +1->Emitted(4, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(4, 13) Source(2, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -50,9 +49,9 @@ sourceFile:a.ts 3 > 4 > class c { > } -1 >Emitted(5, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(5, 2) Source(3, 2) + SourceIndex(0) -3 >Emitted(5, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(5, 6) Source(3, 2) + SourceIndex(0) +1 >Emitted(5, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(5, 2) Source(2, 2) + SourceIndex(0) +3 >Emitted(5, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(5, 6) Source(2, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=a.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.errors.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.errors.txt index 84dfd78e6a342..f9d88bd272751 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.errors.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.errors.txt @@ -7,7 +7,6 @@ error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. Th !!! error TS5055: Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig. !!! error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts', '.js', '.jsx'. ==== tests/cases/compiler/a.ts (0 errors) ==== - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.js b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.js index c23d44b9cb810..e95bfbffaec68 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.js +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.ts] //// //// [a.ts] - class c { } @@ -19,4 +18,4 @@ var c = (function () { } return c; }()); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0E7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.sourcemap.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.sourcemap.txt index c7cb8afe69678..6a0ac0aac3a52 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.sourcemap.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: a.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0E7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== sourceRoot: sources: a.ts =================================================================== @@ -11,15 +11,14 @@ sourceFile:a.ts >>>var c = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function c() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -28,16 +27,16 @@ sourceFile:a.ts 1->class c { > 2 > } -1->Emitted(3, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(3, 6) Source(3, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(3, 6) Source(2, 2) + SourceIndex(0) --- >>> return c; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(4, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(4, 13) Source(3, 2) + SourceIndex(0) +1->Emitted(4, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(4, 13) Source(2, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -50,9 +49,9 @@ sourceFile:a.ts 3 > 4 > class c { > } -1 >Emitted(5, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(5, 2) Source(3, 2) + SourceIndex(0) -3 >Emitted(5, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(5, 6) Source(3, 2) + SourceIndex(0) +1 >Emitted(5, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(5, 2) Source(2, 2) + SourceIndex(0) +3 >Emitted(5, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(5, 6) Source(2, 2) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0E7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7SUFBQTtJQUNBLENBQUM7SUFBRCxRQUFDO0FBQUQsQ0FBQyxBQURELElBQ0MifQ== \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt index c9a4408f4233c..2cdbe8c58f76c 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt @@ -5,7 +5,6 @@ error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. Th !!! error TS6054: File 'tests/cases/compiler/b.js' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts'. !!! error TS6054: File 'tests/cases/compiler/b.js.map' has unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts'. ==== tests/cases/compiler/a.ts (0 errors) ==== - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js index b6c7efa947861..e098aaaa1c913 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsFileCompilationWithMapFileAsJsWithOutDir.ts] //// //// [a.ts] - class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map index 4b90f5d778ccb..c4a4eda35e2b5 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map @@ -1,2 +1,2 @@ //// [a.js.map] -{"version":3,"file":"a.js","sourceRoot":"","sources":["../tests/cases/compiler/a.ts"],"names":[],"mappings":"AACA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} \ No newline at end of file +{"version":3,"file":"a.js","sourceRoot":"","sources":["../tests/cases/compiler/a.ts"],"names":[],"mappings":"AAAA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt index 5c37dd7540992..cee611eb9e818 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt @@ -11,15 +11,14 @@ sourceFile:../tests/cases/compiler/a.ts >>>var c = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function c() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -28,16 +27,16 @@ sourceFile:../tests/cases/compiler/a.ts 1->class c { > 2 > } -1->Emitted(3, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(3, 6) Source(3, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(3, 6) Source(2, 2) + SourceIndex(0) --- >>> return c; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(4, 5) Source(3, 1) + SourceIndex(0) -2 >Emitted(4, 13) Source(3, 2) + SourceIndex(0) +1->Emitted(4, 5) Source(2, 1) + SourceIndex(0) +2 >Emitted(4, 13) Source(2, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -50,9 +49,9 @@ sourceFile:../tests/cases/compiler/a.ts 3 > 4 > class c { > } -1 >Emitted(5, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(5, 2) Source(3, 2) + SourceIndex(0) -3 >Emitted(5, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(5, 6) Source(3, 2) + SourceIndex(0) +1 >Emitted(5, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(5, 2) Source(2, 2) + SourceIndex(0) +3 >Emitted(5, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(5, 6) Source(2, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=a.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsFileFunctionParametersAsOptional.symbols b/tests/baselines/reference/jsFileFunctionParametersAsOptional.symbols index 040b910f378af..17a6b60ebaeaa 100644 --- a/tests/baselines/reference/jsFileFunctionParametersAsOptional.symbols +++ b/tests/baselines/reference/jsFileFunctionParametersAsOptional.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/foo.js === - function f(a, b, c) { } >f : Symbol(f, Decl(foo.js, 0, 0)) ->a : Symbol(a, Decl(foo.js, 1, 11)) ->b : Symbol(b, Decl(foo.js, 1, 13)) ->c : Symbol(c, Decl(foo.js, 1, 16)) +>a : Symbol(a, Decl(foo.js, 0, 11)) +>b : Symbol(b, Decl(foo.js, 0, 13)) +>c : Symbol(c, Decl(foo.js, 0, 16)) === tests/cases/compiler/bar.ts === diff --git a/tests/baselines/reference/jsFileFunctionParametersAsOptional.types b/tests/baselines/reference/jsFileFunctionParametersAsOptional.types index d6d8f9b04a4a1..3260f6fdab76e 100644 --- a/tests/baselines/reference/jsFileFunctionParametersAsOptional.types +++ b/tests/baselines/reference/jsFileFunctionParametersAsOptional.types @@ -1,5 +1,4 @@ === tests/cases/compiler/foo.js === - function f(a, b, c) { } >f : (a: any, b: any, c: any) => void >a : any diff --git a/tests/baselines/reference/jsFileFunctionParametersAsOptional2.errors.txt b/tests/baselines/reference/jsFileFunctionParametersAsOptional2.errors.txt index 26ada935eea09..236827b97bcde 100644 --- a/tests/baselines/reference/jsFileFunctionParametersAsOptional2.errors.txt +++ b/tests/baselines/reference/jsFileFunctionParametersAsOptional2.errors.txt @@ -4,7 +4,6 @@ tests/cases/compiler/bar.ts(3,1): error TS2346: Supplied parameters do not match ==== tests/cases/compiler/foo.js (0 errors) ==== - /** * @param a * @param b diff --git a/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.js b/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.js index c9bec8b56af3b..186918fc15b5c 100644 --- a/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.js +++ b/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/salsa/jsObjectsMarkedAsOpenEnded.ts] //// //// [a.js] - var variable = {}; variable.a = 0; diff --git a/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.symbols b/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.symbols index 35a39ac6a8068..f4dcf96b04b1e 100644 --- a/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.symbols +++ b/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.symbols @@ -1,48 +1,47 @@ === tests/cases/conformance/salsa/a.js === - var variable = {}; ->variable : Symbol(variable, Decl(a.js, 1, 3)) +>variable : Symbol(variable, Decl(a.js, 0, 3)) variable.a = 0; ->variable : Symbol(variable, Decl(a.js, 1, 3)) +>variable : Symbol(variable, Decl(a.js, 0, 3)) class C { ->C : Symbol(C, Decl(a.js, 2, 15)) +>C : Symbol(C, Decl(a.js, 1, 15)) initializedMember = {}; ->initializedMember : Symbol(C.initializedMember, Decl(a.js, 4, 9)) +>initializedMember : Symbol(C.initializedMember, Decl(a.js, 3, 9)) constructor() { this.member = {}; ->this.member : Symbol(C.member, Decl(a.js, 6, 19)) ->this : Symbol(C, Decl(a.js, 2, 15)) ->member : Symbol(C.member, Decl(a.js, 6, 19)) +>this.member : Symbol(C.member, Decl(a.js, 5, 19)) +>this : Symbol(C, Decl(a.js, 1, 15)) +>member : Symbol(C.member, Decl(a.js, 5, 19)) this.member.a = 0; ->this.member : Symbol(C.member, Decl(a.js, 6, 19)) ->this : Symbol(C, Decl(a.js, 2, 15)) ->member : Symbol(C.member, Decl(a.js, 6, 19)) +>this.member : Symbol(C.member, Decl(a.js, 5, 19)) +>this : Symbol(C, Decl(a.js, 1, 15)) +>member : Symbol(C.member, Decl(a.js, 5, 19)) } } var obj = { ->obj : Symbol(obj, Decl(a.js, 12, 3)) +>obj : Symbol(obj, Decl(a.js, 11, 3)) property: {} ->property : Symbol(property, Decl(a.js, 12, 11)) +>property : Symbol(property, Decl(a.js, 11, 11)) }; obj.property.a = 0; ->obj.property : Symbol(property, Decl(a.js, 12, 11)) ->obj : Symbol(obj, Decl(a.js, 12, 3)) ->property : Symbol(property, Decl(a.js, 12, 11)) +>obj.property : Symbol(property, Decl(a.js, 11, 11)) +>obj : Symbol(obj, Decl(a.js, 11, 3)) +>property : Symbol(property, Decl(a.js, 11, 11)) var arr = [{}]; ->arr : Symbol(arr, Decl(a.js, 18, 3)) +>arr : Symbol(arr, Decl(a.js, 17, 3)) function getObj() { ->getObj : Symbol(getObj, Decl(a.js, 18, 15)) +>getObj : Symbol(getObj, Decl(a.js, 17, 15)) return {}; } @@ -50,27 +49,27 @@ function getObj() { === tests/cases/conformance/salsa/b.ts === variable.a = 1; ->variable : Symbol(variable, Decl(a.js, 1, 3)) +>variable : Symbol(variable, Decl(a.js, 0, 3)) (new C()).member.a = 1; ->(new C()).member : Symbol(C.member, Decl(a.js, 6, 19)) ->C : Symbol(C, Decl(a.js, 2, 15)) ->member : Symbol(C.member, Decl(a.js, 6, 19)) +>(new C()).member : Symbol(C.member, Decl(a.js, 5, 19)) +>C : Symbol(C, Decl(a.js, 1, 15)) +>member : Symbol(C.member, Decl(a.js, 5, 19)) (new C()).initializedMember.a = 1; ->(new C()).initializedMember : Symbol(C.initializedMember, Decl(a.js, 4, 9)) ->C : Symbol(C, Decl(a.js, 2, 15)) ->initializedMember : Symbol(C.initializedMember, Decl(a.js, 4, 9)) +>(new C()).initializedMember : Symbol(C.initializedMember, Decl(a.js, 3, 9)) +>C : Symbol(C, Decl(a.js, 1, 15)) +>initializedMember : Symbol(C.initializedMember, Decl(a.js, 3, 9)) obj.property.a = 1; ->obj.property : Symbol(property, Decl(a.js, 12, 11)) ->obj : Symbol(obj, Decl(a.js, 12, 3)) ->property : Symbol(property, Decl(a.js, 12, 11)) +>obj.property : Symbol(property, Decl(a.js, 11, 11)) +>obj : Symbol(obj, Decl(a.js, 11, 3)) +>property : Symbol(property, Decl(a.js, 11, 11)) arr[0].a = 1; ->arr : Symbol(arr, Decl(a.js, 18, 3)) +>arr : Symbol(arr, Decl(a.js, 17, 3)) getObj().a = 1; ->getObj : Symbol(getObj, Decl(a.js, 18, 15)) +>getObj : Symbol(getObj, Decl(a.js, 17, 15)) diff --git a/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.types b/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.types index 97f61e68a5a82..d4f2f66e7ed88 100644 --- a/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.types +++ b/tests/baselines/reference/jsObjectsMarkedAsOpenEnded.types @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/a.js === - var variable = {}; >variable : { [x: string]: any; } >{} : { [x: string]: any; } diff --git a/tests/baselines/reference/jsdocInTypeScript.js b/tests/baselines/reference/jsdocInTypeScript.js new file mode 100644 index 0000000000000..af4b8b6ce0aaa --- /dev/null +++ b/tests/baselines/reference/jsdocInTypeScript.js @@ -0,0 +1,19 @@ +//// [jsdocInTypeScript.ts] +// JSDoc typedef tags are not bound TypeScript files. +/** @typedef {function} T */ +declare const x: T; + +class T { + prop: number; +} + +x.prop; + + +//// [jsdocInTypeScript.js] +var T = (function () { + function T() { + } + return T; +}()); +x.prop; diff --git a/tests/baselines/reference/jsdocInTypeScript.symbols b/tests/baselines/reference/jsdocInTypeScript.symbols new file mode 100644 index 0000000000000..62b6ad3c5390b --- /dev/null +++ b/tests/baselines/reference/jsdocInTypeScript.symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/jsdocInTypeScript.ts === +// JSDoc typedef tags are not bound TypeScript files. +/** @typedef {function} T */ +declare const x: T; +>x : Symbol(x, Decl(jsdocInTypeScript.ts, 2, 13)) +>T : Symbol(T, Decl(jsdocInTypeScript.ts, 2, 19)) + +class T { +>T : Symbol(T, Decl(jsdocInTypeScript.ts, 2, 19)) + + prop: number; +>prop : Symbol(T.prop, Decl(jsdocInTypeScript.ts, 4, 9)) +} + +x.prop; +>x.prop : Symbol(T.prop, Decl(jsdocInTypeScript.ts, 4, 9)) +>x : Symbol(x, Decl(jsdocInTypeScript.ts, 2, 13)) +>prop : Symbol(T.prop, Decl(jsdocInTypeScript.ts, 4, 9)) + diff --git a/tests/baselines/reference/jsdocInTypeScript.types b/tests/baselines/reference/jsdocInTypeScript.types new file mode 100644 index 0000000000000..03ff2929e0ad7 --- /dev/null +++ b/tests/baselines/reference/jsdocInTypeScript.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/jsdocInTypeScript.ts === +// JSDoc typedef tags are not bound TypeScript files. +/** @typedef {function} T */ +declare const x: T; +>x : T +>T : T + +class T { +>T : T + + prop: number; +>prop : number +} + +x.prop; +>x.prop : number +>x : T +>prop : number + diff --git a/tests/baselines/reference/json.stringify.js b/tests/baselines/reference/json.stringify.js index 8dba6a892af27..a37485bdfa28d 100644 --- a/tests/baselines/reference/json.stringify.js +++ b/tests/baselines/reference/json.stringify.js @@ -1,5 +1,4 @@ //// [json.stringify.ts] - var value = null; JSON.stringify(value, undefined, 2); JSON.stringify(value, null, 2); diff --git a/tests/baselines/reference/json.stringify.symbols b/tests/baselines/reference/json.stringify.symbols index 3c3c20ef30a93..98afda4c6e77b 100644 --- a/tests/baselines/reference/json.stringify.symbols +++ b/tests/baselines/reference/json.stringify.symbols @@ -1,39 +1,38 @@ === tests/cases/compiler/json.stringify.ts === - var value = null; ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) JSON.stringify(value, undefined, 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) >undefined : Symbol(undefined) JSON.stringify(value, null, 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) JSON.stringify(value, ["a", 1], 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) JSON.stringify(value, (k) => undefined, 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) ->k : Symbol(k, Decl(json.stringify.ts, 5, 23)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) +>k : Symbol(k, Decl(json.stringify.ts, 4, 23)) >undefined : Symbol(undefined) JSON.stringify(value, undefined, 2); >JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(json.stringify.ts, 1, 3)) +>value : Symbol(value, Decl(json.stringify.ts, 0, 3)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/json.stringify.types b/tests/baselines/reference/json.stringify.types index b063b06d8d07c..a25eac5aaf7ad 100644 --- a/tests/baselines/reference/json.stringify.types +++ b/tests/baselines/reference/json.stringify.types @@ -1,5 +1,4 @@ === tests/cases/compiler/json.stringify.ts === - var value = null; >value : null >null : null diff --git a/tests/baselines/reference/jsxAndTypeAssertion.errors.txt b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt index d0e9bcf145bbe..5aa92086c3795 100644 --- a/tests/baselines/reference/jsxAndTypeAssertion.errors.txt +++ b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt @@ -1,21 +1,20 @@ -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,6): error TS17008: JSX element 'any' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,13): error TS2304: Cannot find name 'test'. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,17): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(9,6): error TS17008: JSX element 'any' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,6): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,32): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(13,36): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,17): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,45): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,2): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,8): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,13): error TS17008: JSX element 'foo' has no corresponding closing tag. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS1005: ':' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS1005: ' ~~~~ diff --git a/tests/baselines/reference/jsxAttributeWithoutExpressionReact.js b/tests/baselines/reference/jsxAttributeWithoutExpressionReact.js index f07cbabd7f812..3603c7989b87e 100644 --- a/tests/baselines/reference/jsxAttributeWithoutExpressionReact.js +++ b/tests/baselines/reference/jsxAttributeWithoutExpressionReact.js @@ -1,5 +1,4 @@ //// [jsxAttributeWithoutExpressionReact.tsx] - declare var React: any; diff --git a/tests/baselines/reference/jsxEmitAttributeWithPreserve.symbols b/tests/baselines/reference/jsxEmitAttributeWithPreserve.symbols index a5f910776b0d7..27cdac0100bdd 100644 --- a/tests/baselines/reference/jsxEmitAttributeWithPreserve.symbols +++ b/tests/baselines/reference/jsxEmitAttributeWithPreserve.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/jsxEmitAttributeWithPreserve.tsx === - declare var React: any; ->React : Symbol(React, Decl(jsxEmitAttributeWithPreserve.tsx, 1, 11)) +>React : Symbol(React, Decl(jsxEmitAttributeWithPreserve.tsx, 0, 11)) >foo : Symbol(unknown) ->data : Symbol(data, Decl(jsxEmitAttributeWithPreserve.tsx, 2, 4)) +>data : Symbol(data, Decl(jsxEmitAttributeWithPreserve.tsx, 1, 4)) diff --git a/tests/baselines/reference/jsxEmitAttributeWithPreserve.types b/tests/baselines/reference/jsxEmitAttributeWithPreserve.types index 7d218f422bf06..1f6cc13bd08c0 100644 --- a/tests/baselines/reference/jsxEmitAttributeWithPreserve.types +++ b/tests/baselines/reference/jsxEmitAttributeWithPreserve.types @@ -1,5 +1,4 @@ === tests/cases/compiler/jsxEmitAttributeWithPreserve.tsx === - declare var React: any; >React : any diff --git a/tests/baselines/reference/jsxEmitWithAttributes.js b/tests/baselines/reference/jsxEmitWithAttributes.js index dd4d326268b2d..f92ee5acb33c5 100644 --- a/tests/baselines/reference/jsxEmitWithAttributes.js +++ b/tests/baselines/reference/jsxEmitWithAttributes.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxEmitWithAttributes.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxEmitWithAttributes.symbols b/tests/baselines/reference/jsxEmitWithAttributes.symbols index f2579903d3e7d..f20470ebb6b37 100644 --- a/tests/baselines/reference/jsxEmitWithAttributes.symbols +++ b/tests/baselines/reference/jsxEmitWithAttributes.symbols @@ -1,57 +1,56 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) interface Element { ->Element : Symbol(Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(Element, Decl(Element.ts, 0, 23)) name: string; ->name : Symbol(Element.name, Decl(Element.ts, 2, 23)) +>name : Symbol(Element.name, Decl(Element.ts, 1, 23)) isIntrinsic: boolean; ->isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 3, 21)) +>isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 2, 21)) isCustomElement: boolean; ->isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 4, 29)) +>isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 3, 29)) toString(renderId?: number): string; ->toString : Symbol(Element.toString, Decl(Element.ts, 5, 33)) ->renderId : Symbol(renderId, Decl(Element.ts, 6, 17)) +>toString : Symbol(Element.toString, Decl(Element.ts, 4, 33)) +>renderId : Symbol(renderId, Decl(Element.ts, 5, 17)) bindDOM(renderId?: number): number; ->bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 6, 44)) ->renderId : Symbol(renderId, Decl(Element.ts, 7, 16)) +>bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 5, 44)) +>renderId : Symbol(renderId, Decl(Element.ts, 6, 16)) resetComponent(): void; ->resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 7, 43)) +>resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 6, 43)) instantiateComponents(renderId?: number): number; ->instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 8, 31)) ->renderId : Symbol(renderId, Decl(Element.ts, 9, 30)) +>instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 7, 31)) +>renderId : Symbol(renderId, Decl(Element.ts, 8, 30)) props: any; ->props : Symbol(Element.props, Decl(Element.ts, 9, 57)) +>props : Symbol(Element.props, Decl(Element.ts, 8, 57)) } } export namespace Element { ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) export function isElement(el: any): el is JSX.Element { ->isElement : Symbol(isElement, Decl(Element.ts, 13, 26)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>isElement : Symbol(isElement, Decl(Element.ts, 12, 26)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) ->Element : Symbol(JSX.Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(JSX.Element, Decl(Element.ts, 0, 23)) return el.markAsChildOfRootElement !== undefined; ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >undefined : Symbol(undefined) } export function createElement(args: any[]) { ->createElement : Symbol(createElement, Decl(Element.ts, 16, 5)) ->args : Symbol(args, Decl(Element.ts, 18, 34)) +>createElement : Symbol(createElement, Decl(Element.ts, 15, 5)) +>args : Symbol(args, Decl(Element.ts, 17, 34)) return { } @@ -59,21 +58,21 @@ export namespace Element { } export let createElement = Element.createElement; ->createElement : Symbol(createElement, Decl(Element.ts, 25, 10)) ->Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) ->createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>createElement : Symbol(createElement, Decl(Element.ts, 24, 10)) +>Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) +>createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) function toCamelCase(text: string): string { ->toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 25, 49)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 24, 49)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) return text[0].toLowerCase() + text.substring(1); >text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) >text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) } diff --git a/tests/baselines/reference/jsxEmitWithAttributes.types b/tests/baselines/reference/jsxEmitWithAttributes.types index 724aed319ec03..044b65222a906 100644 --- a/tests/baselines/reference/jsxEmitWithAttributes.types +++ b/tests/baselines/reference/jsxEmitWithAttributes.types @@ -1,5 +1,4 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/jsxFactoryAndReactNamespace.errors.txt b/tests/baselines/reference/jsxFactoryAndReactNamespace.errors.txt index c4859fd534cad..c1734f6304c25 100644 --- a/tests/baselines/reference/jsxFactoryAndReactNamespace.errors.txt +++ b/tests/baselines/reference/jsxFactoryAndReactNamespace.errors.txt @@ -3,7 +3,6 @@ error TS5053: Option 'reactNamespace' cannot be specified with option 'jsxFactor !!! error TS5053: Option 'reactNamespace' cannot be specified with option 'jsxFactory'. ==== tests/cases/compiler/Element.ts (0 errors) ==== - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryAndReactNamespace.js b/tests/baselines/reference/jsxFactoryAndReactNamespace.js index a864da65dbb6d..277a74a8c2f73 100644 --- a/tests/baselines/reference/jsxFactoryAndReactNamespace.js +++ b/tests/baselines/reference/jsxFactoryAndReactNamespace.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryAndReactNamespace.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryIdentifier.js b/tests/baselines/reference/jsxFactoryIdentifier.js index 9beff01d7077e..3a3c360a8f170 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.js +++ b/tests/baselines/reference/jsxFactoryIdentifier.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryIdentifier.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryIdentifier.js.map b/tests/baselines/reference/jsxFactoryIdentifier.js.map index 57ff760b8a883..ab23c9b10b3ed 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.js.map +++ b/tests/baselines/reference/jsxFactoryIdentifier.js.map @@ -1,3 +1,3 @@ //// [Element.js.map] -{"version":3,"file":"Element.js","sourceRoot":"","sources":["Element.ts"],"names":[],"mappings":";;AAaA,IAAiB,OAAO,CAUvB;AAVD,WAAiB,OAAO;IACpB,mBAA0B,EAAO;QAC7B,MAAM,CAAC,EAAE,CAAC,wBAAwB,KAAK,SAAS,CAAC;IACrD,CAAC;IAFe,iBAAS,YAExB,CAAA;IAED,uBAA8B,IAAW;QAErC,MAAM,CAAC,EACN,CAAA;IACL,CAAC;IAJe,qBAAa,gBAI5B,CAAA;AACL,CAAC,EAVgB,OAAO,GAAP,eAAO,KAAP,eAAO,QAUvB;AAEU,QAAA,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAEjD,qBAAqB,IAAY;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC"}//// [test.js.map] +{"version":3,"file":"Element.js","sourceRoot":"","sources":["Element.ts"],"names":[],"mappings":";;AAYA,IAAiB,OAAO,CAUvB;AAVD,WAAiB,OAAO;IACpB,mBAA0B,EAAO;QAC7B,MAAM,CAAC,EAAE,CAAC,wBAAwB,KAAK,SAAS,CAAC;IACrD,CAAC;IAFe,iBAAS,YAExB,CAAA;IAED,uBAA8B,IAAW;QAErC,MAAM,CAAC,EACN,CAAA;IACL,CAAC;IAJe,qBAAa,gBAI5B,CAAA;AACL,CAAC,EAVgB,OAAO,GAAP,eAAO,KAAP,eAAO,QAUvB;AAEU,QAAA,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAEjD,qBAAqB,IAAY;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC"}//// [test.js.map] {"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAAA,uCAAmC;AACnC,IAAI,aAAa,GAAG,iBAAO,CAAC,aAAa,CAAC;AAC1C,IAAI,CAIH,CAAC;AAEF;IACC,IAAI;QACH,MAAM,CAAC;YACN,wBAAM,OAAO,EAAC,YAAY,GAAQ;YAClC,wBAAM,OAAO,EAAE,CAAC,CAAC,CAAE,CAAC,CAAC,GAAS;SAC9B,CAAC;IACH,CAAC;CACD"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryIdentifier.sourcemap.txt b/tests/baselines/reference/jsxFactoryIdentifier.sourcemap.txt index 6101ee1d5e788..c0359aa61d0cd 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryIdentifier.sourcemap.txt @@ -16,8 +16,7 @@ sourceFile:Element.ts 3 > ^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^-> -1 > - >declare namespace JSX { +1 >declare namespace JSX { > interface Element { > name: string; > isIntrinsic: boolean; @@ -43,10 +42,10 @@ sourceFile:Element.ts > } > } > } -1 >Emitted(3, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(3, 5) Source(14, 18) + SourceIndex(0) -3 >Emitted(3, 12) Source(14, 25) + SourceIndex(0) -4 >Emitted(3, 13) Source(24, 2) + SourceIndex(0) +1 >Emitted(3, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(3, 5) Source(13, 18) + SourceIndex(0) +3 >Emitted(3, 12) Source(13, 25) + SourceIndex(0) +4 >Emitted(3, 13) Source(23, 2) + SourceIndex(0) --- >>>(function (Element) { 1-> @@ -56,9 +55,9 @@ sourceFile:Element.ts 1-> 2 >export namespace 3 > Element -1->Emitted(4, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(4, 12) Source(14, 18) + SourceIndex(0) -3 >Emitted(4, 19) Source(14, 25) + SourceIndex(0) +1->Emitted(4, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(4, 12) Source(13, 18) + SourceIndex(0) +3 >Emitted(4, 19) Source(13, 25) + SourceIndex(0) --- >>> function isElement(el) { 1->^^^^ @@ -69,9 +68,9 @@ sourceFile:Element.ts > 2 > export function isElement( 3 > el: any -1->Emitted(5, 5) Source(15, 5) + SourceIndex(0) -2 >Emitted(5, 24) Source(15, 31) + SourceIndex(0) -3 >Emitted(5, 26) Source(15, 38) + SourceIndex(0) +1->Emitted(5, 5) Source(14, 5) + SourceIndex(0) +2 >Emitted(5, 24) Source(14, 31) + SourceIndex(0) +3 >Emitted(5, 26) Source(14, 38) + SourceIndex(0) --- >>> return el.markAsChildOfRootElement !== undefined; 1->^^^^^^^^ @@ -93,15 +92,15 @@ sourceFile:Element.ts 7 > !== 8 > undefined 9 > ; -1->Emitted(6, 9) Source(16, 9) + SourceIndex(0) -2 >Emitted(6, 15) Source(16, 15) + SourceIndex(0) -3 >Emitted(6, 16) Source(16, 16) + SourceIndex(0) -4 >Emitted(6, 18) Source(16, 18) + SourceIndex(0) -5 >Emitted(6, 19) Source(16, 19) + SourceIndex(0) -6 >Emitted(6, 43) Source(16, 43) + SourceIndex(0) -7 >Emitted(6, 48) Source(16, 48) + SourceIndex(0) -8 >Emitted(6, 57) Source(16, 57) + SourceIndex(0) -9 >Emitted(6, 58) Source(16, 58) + SourceIndex(0) +1->Emitted(6, 9) Source(15, 9) + SourceIndex(0) +2 >Emitted(6, 15) Source(15, 15) + SourceIndex(0) +3 >Emitted(6, 16) Source(15, 16) + SourceIndex(0) +4 >Emitted(6, 18) Source(15, 18) + SourceIndex(0) +5 >Emitted(6, 19) Source(15, 19) + SourceIndex(0) +6 >Emitted(6, 43) Source(15, 43) + SourceIndex(0) +7 >Emitted(6, 48) Source(15, 48) + SourceIndex(0) +8 >Emitted(6, 57) Source(15, 57) + SourceIndex(0) +9 >Emitted(6, 58) Source(15, 58) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -110,8 +109,8 @@ sourceFile:Element.ts 1 > > 2 > } -1 >Emitted(7, 5) Source(17, 5) + SourceIndex(0) -2 >Emitted(7, 6) Source(17, 6) + SourceIndex(0) +1 >Emitted(7, 5) Source(16, 5) + SourceIndex(0) +2 >Emitted(7, 6) Source(16, 6) + SourceIndex(0) --- >>> Element.isElement = isElement; 1->^^^^ @@ -125,10 +124,10 @@ sourceFile:Element.ts > return el.markAsChildOfRootElement !== undefined; > } 4 > -1->Emitted(8, 5) Source(15, 21) + SourceIndex(0) -2 >Emitted(8, 22) Source(15, 30) + SourceIndex(0) -3 >Emitted(8, 34) Source(17, 6) + SourceIndex(0) -4 >Emitted(8, 35) Source(17, 6) + SourceIndex(0) +1->Emitted(8, 5) Source(14, 21) + SourceIndex(0) +2 >Emitted(8, 22) Source(14, 30) + SourceIndex(0) +3 >Emitted(8, 34) Source(16, 6) + SourceIndex(0) +4 >Emitted(8, 35) Source(16, 6) + SourceIndex(0) --- >>> function createElement(args) { 1->^^^^ @@ -139,9 +138,9 @@ sourceFile:Element.ts > 2 > export function createElement( 3 > args: any[] -1->Emitted(9, 5) Source(19, 5) + SourceIndex(0) -2 >Emitted(9, 28) Source(19, 35) + SourceIndex(0) -3 >Emitted(9, 32) Source(19, 46) + SourceIndex(0) +1->Emitted(9, 5) Source(18, 5) + SourceIndex(0) +2 >Emitted(9, 28) Source(18, 35) + SourceIndex(0) +3 >Emitted(9, 32) Source(18, 46) + SourceIndex(0) --- >>> return {}; 1 >^^^^^^^^ @@ -157,11 +156,11 @@ sourceFile:Element.ts 4 > { > } 5 > -1 >Emitted(10, 9) Source(21, 9) + SourceIndex(0) -2 >Emitted(10, 15) Source(21, 15) + SourceIndex(0) -3 >Emitted(10, 16) Source(21, 16) + SourceIndex(0) -4 >Emitted(10, 18) Source(22, 10) + SourceIndex(0) -5 >Emitted(10, 19) Source(22, 10) + SourceIndex(0) +1 >Emitted(10, 9) Source(20, 9) + SourceIndex(0) +2 >Emitted(10, 15) Source(20, 15) + SourceIndex(0) +3 >Emitted(10, 16) Source(20, 16) + SourceIndex(0) +4 >Emitted(10, 18) Source(21, 10) + SourceIndex(0) +5 >Emitted(10, 19) Source(21, 10) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -170,8 +169,8 @@ sourceFile:Element.ts 1 > > 2 > } -1 >Emitted(11, 5) Source(23, 5) + SourceIndex(0) -2 >Emitted(11, 6) Source(23, 6) + SourceIndex(0) +1 >Emitted(11, 5) Source(22, 5) + SourceIndex(0) +2 >Emitted(11, 6) Source(22, 6) + SourceIndex(0) --- >>> Element.createElement = createElement; 1->^^^^ @@ -187,10 +186,10 @@ sourceFile:Element.ts > } > } 4 > -1->Emitted(12, 5) Source(19, 21) + SourceIndex(0) -2 >Emitted(12, 26) Source(19, 34) + SourceIndex(0) -3 >Emitted(12, 42) Source(23, 6) + SourceIndex(0) -4 >Emitted(12, 43) Source(23, 6) + SourceIndex(0) +1->Emitted(12, 5) Source(18, 21) + SourceIndex(0) +2 >Emitted(12, 26) Source(18, 34) + SourceIndex(0) +3 >Emitted(12, 42) Source(22, 6) + SourceIndex(0) +4 >Emitted(12, 43) Source(22, 6) + SourceIndex(0) --- >>>})(Element = exports.Element || (exports.Element = {})); 1-> @@ -222,15 +221,15 @@ sourceFile:Element.ts > } > } > } -1->Emitted(13, 1) Source(24, 1) + SourceIndex(0) -2 >Emitted(13, 2) Source(24, 2) + SourceIndex(0) -3 >Emitted(13, 4) Source(14, 18) + SourceIndex(0) -4 >Emitted(13, 11) Source(14, 25) + SourceIndex(0) -5 >Emitted(13, 14) Source(14, 18) + SourceIndex(0) -6 >Emitted(13, 29) Source(14, 25) + SourceIndex(0) -7 >Emitted(13, 34) Source(14, 18) + SourceIndex(0) -8 >Emitted(13, 49) Source(14, 25) + SourceIndex(0) -9 >Emitted(13, 57) Source(24, 2) + SourceIndex(0) +1->Emitted(13, 1) Source(23, 1) + SourceIndex(0) +2 >Emitted(13, 2) Source(23, 2) + SourceIndex(0) +3 >Emitted(13, 4) Source(13, 18) + SourceIndex(0) +4 >Emitted(13, 11) Source(13, 25) + SourceIndex(0) +5 >Emitted(13, 14) Source(13, 18) + SourceIndex(0) +6 >Emitted(13, 29) Source(13, 25) + SourceIndex(0) +7 >Emitted(13, 34) Source(13, 18) + SourceIndex(0) +8 >Emitted(13, 49) Source(13, 25) + SourceIndex(0) +9 >Emitted(13, 57) Source(23, 2) + SourceIndex(0) --- >>>exports.createElement = Element.createElement; 1 > @@ -251,14 +250,14 @@ sourceFile:Element.ts 6 > . 7 > createElement 8 > ; -1 >Emitted(14, 1) Source(26, 12) + SourceIndex(0) -2 >Emitted(14, 9) Source(26, 12) + SourceIndex(0) -3 >Emitted(14, 22) Source(26, 25) + SourceIndex(0) -4 >Emitted(14, 25) Source(26, 28) + SourceIndex(0) -5 >Emitted(14, 32) Source(26, 35) + SourceIndex(0) -6 >Emitted(14, 33) Source(26, 36) + SourceIndex(0) -7 >Emitted(14, 46) Source(26, 49) + SourceIndex(0) -8 >Emitted(14, 47) Source(26, 50) + SourceIndex(0) +1 >Emitted(14, 1) Source(25, 12) + SourceIndex(0) +2 >Emitted(14, 9) Source(25, 12) + SourceIndex(0) +3 >Emitted(14, 22) Source(25, 25) + SourceIndex(0) +4 >Emitted(14, 25) Source(25, 28) + SourceIndex(0) +5 >Emitted(14, 32) Source(25, 35) + SourceIndex(0) +6 >Emitted(14, 33) Source(25, 36) + SourceIndex(0) +7 >Emitted(14, 46) Source(25, 49) + SourceIndex(0) +8 >Emitted(14, 47) Source(25, 50) + SourceIndex(0) --- >>>function toCamelCase(text) { 1 > @@ -270,9 +269,9 @@ sourceFile:Element.ts > 2 >function toCamelCase( 3 > text: string -1 >Emitted(15, 1) Source(28, 1) + SourceIndex(0) -2 >Emitted(15, 22) Source(28, 22) + SourceIndex(0) -3 >Emitted(15, 26) Source(28, 34) + SourceIndex(0) +1 >Emitted(15, 1) Source(27, 1) + SourceIndex(0) +2 >Emitted(15, 22) Source(27, 22) + SourceIndex(0) +3 >Emitted(15, 26) Source(27, 34) + SourceIndex(0) --- >>> return text[0].toLowerCase() + text.substring(1); 1->^^^^ @@ -312,24 +311,24 @@ sourceFile:Element.ts 16> 1 17> ) 18> ; -1->Emitted(16, 5) Source(29, 5) + SourceIndex(0) -2 >Emitted(16, 11) Source(29, 11) + SourceIndex(0) -3 >Emitted(16, 12) Source(29, 12) + SourceIndex(0) -4 >Emitted(16, 16) Source(29, 16) + SourceIndex(0) -5 >Emitted(16, 17) Source(29, 17) + SourceIndex(0) -6 >Emitted(16, 18) Source(29, 18) + SourceIndex(0) -7 >Emitted(16, 19) Source(29, 19) + SourceIndex(0) -8 >Emitted(16, 20) Source(29, 20) + SourceIndex(0) -9 >Emitted(16, 31) Source(29, 31) + SourceIndex(0) -10>Emitted(16, 33) Source(29, 33) + SourceIndex(0) -11>Emitted(16, 36) Source(29, 36) + SourceIndex(0) -12>Emitted(16, 40) Source(29, 40) + SourceIndex(0) -13>Emitted(16, 41) Source(29, 41) + SourceIndex(0) -14>Emitted(16, 50) Source(29, 50) + SourceIndex(0) -15>Emitted(16, 51) Source(29, 51) + SourceIndex(0) -16>Emitted(16, 52) Source(29, 52) + SourceIndex(0) -17>Emitted(16, 53) Source(29, 53) + SourceIndex(0) -18>Emitted(16, 54) Source(29, 54) + SourceIndex(0) +1->Emitted(16, 5) Source(28, 5) + SourceIndex(0) +2 >Emitted(16, 11) Source(28, 11) + SourceIndex(0) +3 >Emitted(16, 12) Source(28, 12) + SourceIndex(0) +4 >Emitted(16, 16) Source(28, 16) + SourceIndex(0) +5 >Emitted(16, 17) Source(28, 17) + SourceIndex(0) +6 >Emitted(16, 18) Source(28, 18) + SourceIndex(0) +7 >Emitted(16, 19) Source(28, 19) + SourceIndex(0) +8 >Emitted(16, 20) Source(28, 20) + SourceIndex(0) +9 >Emitted(16, 31) Source(28, 31) + SourceIndex(0) +10>Emitted(16, 33) Source(28, 33) + SourceIndex(0) +11>Emitted(16, 36) Source(28, 36) + SourceIndex(0) +12>Emitted(16, 40) Source(28, 40) + SourceIndex(0) +13>Emitted(16, 41) Source(28, 41) + SourceIndex(0) +14>Emitted(16, 50) Source(28, 50) + SourceIndex(0) +15>Emitted(16, 51) Source(28, 51) + SourceIndex(0) +16>Emitted(16, 52) Source(28, 52) + SourceIndex(0) +17>Emitted(16, 53) Source(28, 53) + SourceIndex(0) +18>Emitted(16, 54) Source(28, 54) + SourceIndex(0) --- >>>} 1 > @@ -338,8 +337,8 @@ sourceFile:Element.ts 1 > > 2 >} -1 >Emitted(17, 1) Source(30, 1) + SourceIndex(0) -2 >Emitted(17, 2) Source(30, 2) + SourceIndex(0) +1 >Emitted(17, 1) Source(29, 1) + SourceIndex(0) +2 >Emitted(17, 2) Source(29, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=Element.js.map=================================================================== JsFile: test.js diff --git a/tests/baselines/reference/jsxFactoryIdentifier.symbols b/tests/baselines/reference/jsxFactoryIdentifier.symbols index b6d6856bccbd8..b66976f8884b4 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.symbols +++ b/tests/baselines/reference/jsxFactoryIdentifier.symbols @@ -1,57 +1,56 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) interface Element { ->Element : Symbol(Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(Element, Decl(Element.ts, 0, 23)) name: string; ->name : Symbol(Element.name, Decl(Element.ts, 2, 23)) +>name : Symbol(Element.name, Decl(Element.ts, 1, 23)) isIntrinsic: boolean; ->isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 3, 21)) +>isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 2, 21)) isCustomElement: boolean; ->isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 4, 29)) +>isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 3, 29)) toString(renderId?: number): string; ->toString : Symbol(Element.toString, Decl(Element.ts, 5, 33)) ->renderId : Symbol(renderId, Decl(Element.ts, 6, 17)) +>toString : Symbol(Element.toString, Decl(Element.ts, 4, 33)) +>renderId : Symbol(renderId, Decl(Element.ts, 5, 17)) bindDOM(renderId?: number): number; ->bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 6, 44)) ->renderId : Symbol(renderId, Decl(Element.ts, 7, 16)) +>bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 5, 44)) +>renderId : Symbol(renderId, Decl(Element.ts, 6, 16)) resetComponent(): void; ->resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 7, 43)) +>resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 6, 43)) instantiateComponents(renderId?: number): number; ->instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 8, 31)) ->renderId : Symbol(renderId, Decl(Element.ts, 9, 30)) +>instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 7, 31)) +>renderId : Symbol(renderId, Decl(Element.ts, 8, 30)) props: any; ->props : Symbol(Element.props, Decl(Element.ts, 9, 57)) +>props : Symbol(Element.props, Decl(Element.ts, 8, 57)) } } export namespace Element { ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) export function isElement(el: any): el is JSX.Element { ->isElement : Symbol(isElement, Decl(Element.ts, 13, 26)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>isElement : Symbol(isElement, Decl(Element.ts, 12, 26)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) ->Element : Symbol(JSX.Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(JSX.Element, Decl(Element.ts, 0, 23)) return el.markAsChildOfRootElement !== undefined; ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >undefined : Symbol(undefined) } export function createElement(args: any[]) { ->createElement : Symbol(createElement, Decl(Element.ts, 16, 5)) ->args : Symbol(args, Decl(Element.ts, 18, 34)) +>createElement : Symbol(createElement, Decl(Element.ts, 15, 5)) +>args : Symbol(args, Decl(Element.ts, 17, 34)) return { } @@ -59,21 +58,21 @@ export namespace Element { } export let createElement = Element.createElement; ->createElement : Symbol(createElement, Decl(Element.ts, 25, 10)) ->Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) ->createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>createElement : Symbol(createElement, Decl(Element.ts, 24, 10)) +>Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) +>createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) function toCamelCase(text: string): string { ->toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 25, 49)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 24, 49)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) return text[0].toLowerCase() + text.substring(1); >text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) >text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) } @@ -83,9 +82,9 @@ import { Element} from './Element'; let createElement = Element.createElement; >createElement : Symbol(createElement, Decl(test.tsx, 1, 3)) ->Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) >Element : Symbol(Element, Decl(test.tsx, 0, 8)) ->createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) let c: { >c : Symbol(c, Decl(test.tsx, 2, 3)) diff --git a/tests/baselines/reference/jsxFactoryIdentifier.types b/tests/baselines/reference/jsxFactoryIdentifier.types index cb44bb0ac0f89..76f49568531b8 100644 --- a/tests/baselines/reference/jsxFactoryIdentifier.types +++ b/tests/baselines/reference/jsxFactoryIdentifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js index 05da89d0d85aa..f72748642bb90 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js @@ -1,5 +1,4 @@ //// [test.tsx] - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js.map b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js.map index c72e1bf8057c5..c0e44a28e3fb3 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js.map +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.js.map @@ -1,2 +1,2 @@ //// [test.js.map] -{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAOA;IACI,MAAM,CAAC,aAAa;QAChB,MAAM,CAAC,0BAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file +{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAMA;IACI,MAAM,CAAC,aAAa;QAChB,MAAM,CAAC,0BAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.sourcemap.txt b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.sourcemap.txt index b2d30177b1d0d..b8836a65a1c8b 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.sourcemap.txt @@ -13,15 +13,14 @@ sourceFile:test.tsx >>>class AppComponent { 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >declare module JSX { +1 >declare module JSX { > interface IntrinsicElements { > [s: string]: any; > } >} > > -1 >Emitted(3, 1) Source(8, 1) + SourceIndex(0) +1 >Emitted(3, 1) Source(7, 1) + SourceIndex(0) --- >>> render(createElement) { 1->^^^^ @@ -34,10 +33,10 @@ sourceFile:test.tsx 2 > render 3 > ( 4 > createElement -1->Emitted(4, 5) Source(9, 5) + SourceIndex(0) -2 >Emitted(4, 11) Source(9, 11) + SourceIndex(0) -3 >Emitted(4, 12) Source(9, 12) + SourceIndex(0) -4 >Emitted(4, 25) Source(9, 25) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 5) + SourceIndex(0) +2 >Emitted(4, 11) Source(8, 11) + SourceIndex(0) +3 >Emitted(4, 12) Source(8, 12) + SourceIndex(0) +4 >Emitted(4, 25) Source(8, 25) + SourceIndex(0) --- >>> return createElement("div", null); 1->^^^^^^^^ @@ -51,11 +50,11 @@ sourceFile:test.tsx 3 > 4 >
5 > ; -1->Emitted(5, 9) Source(10, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) -4 >Emitted(5, 42) Source(10, 23) + SourceIndex(0) -5 >Emitted(5, 43) Source(10, 24) + SourceIndex(0) +1->Emitted(5, 9) Source(9, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(9, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(9, 16) + SourceIndex(0) +4 >Emitted(5, 42) Source(9, 23) + SourceIndex(0) +5 >Emitted(5, 43) Source(9, 24) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -63,15 +62,15 @@ sourceFile:test.tsx 1 > > 2 > } -1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(10, 6) + SourceIndex(0) --- >>>} 1 >^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > >} -1 >Emitted(7, 2) Source(12, 2) + SourceIndex(0) +1 >Emitted(7, 2) Source(11, 2) + SourceIndex(0) --- >>>exports.AppComponent = AppComponent; 1-> @@ -82,7 +81,7 @@ sourceFile:test.tsx > return
; > } >} -1->Emitted(8, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(8, 37) Source(12, 2) + SourceIndex(0) +1->Emitted(8, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(8, 37) Source(11, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=test.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.symbols b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.symbols index 865292092a56c..069e377d47be2 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.symbols +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/test.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(test.tsx, 0, 0)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(test.tsx, 1, 20)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(test.tsx, 0, 20)) [s: string]: any; ->s : Symbol(s, Decl(test.tsx, 3, 9)) +>s : Symbol(s, Decl(test.tsx, 2, 9)) } } export class AppComponent { ->AppComponent : Symbol(AppComponent, Decl(test.tsx, 5, 1)) +>AppComponent : Symbol(AppComponent, Decl(test.tsx, 4, 1)) render(createElement) { ->render : Symbol(AppComponent.render, Decl(test.tsx, 7, 27)) ->createElement : Symbol(createElement, Decl(test.tsx, 8, 11)) +>render : Symbol(AppComponent.render, Decl(test.tsx, 6, 27)) +>createElement : Symbol(createElement, Decl(test.tsx, 7, 11)) return
; >div : Symbol(unknown) diff --git a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.types b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.types index d55737d98aed5..e2fa620b4ac1d 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierAsParameter.types +++ b/tests/baselines/reference/jsxFactoryIdentifierAsParameter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.errors.txt b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.errors.txt index 99e039a045fbc..2b51171a6f1b9 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.errors.txt +++ b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.tsx(10,17): error TS2304: Cannot find name 'createElement'. +tests/cases/compiler/test.tsx(9,17): error TS2304: Cannot find name 'createElement'. ==== tests/cases/compiler/test.tsx (1 errors) ==== - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js index c9f5f3465e353..8ae3a3842a783 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js +++ b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js @@ -1,5 +1,4 @@ //// [test.tsx] - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js.map b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js.map index 66666a526d62d..28e14ed6be56f 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js.map +++ b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.js.map @@ -1,2 +1,2 @@ //// [test.js.map] -{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAOA;IACI,MAAM;QACF,MAAM,CAAC,0BAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file +{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAMA;IACI,MAAM;QACF,MAAM,CAAC,0BAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.sourcemap.txt b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.sourcemap.txt index 1a77ab3eae17b..378b69deb690f 100644 --- a/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.sourcemap.txt @@ -13,15 +13,14 @@ sourceFile:test.tsx >>>class AppComponent { 1 > 2 >^^^^^^^^^^^^^^^-> -1 > - >declare module JSX { +1 >declare module JSX { > interface IntrinsicElements { > [s: string]: any; > } >} > > -1 >Emitted(3, 1) Source(8, 1) + SourceIndex(0) +1 >Emitted(3, 1) Source(7, 1) + SourceIndex(0) --- >>> render() { 1->^^^^ @@ -30,8 +29,8 @@ sourceFile:test.tsx 1->export class AppComponent { > 2 > render -1->Emitted(4, 5) Source(9, 5) + SourceIndex(0) -2 >Emitted(4, 11) Source(9, 11) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 5) + SourceIndex(0) +2 >Emitted(4, 11) Source(8, 11) + SourceIndex(0) --- >>> return createElement("div", null); 1->^^^^^^^^ @@ -45,11 +44,11 @@ sourceFile:test.tsx 3 > 4 >
5 > ; -1->Emitted(5, 9) Source(10, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) -4 >Emitted(5, 42) Source(10, 23) + SourceIndex(0) -5 >Emitted(5, 43) Source(10, 24) + SourceIndex(0) +1->Emitted(5, 9) Source(9, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(9, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(9, 16) + SourceIndex(0) +4 >Emitted(5, 42) Source(9, 23) + SourceIndex(0) +5 >Emitted(5, 43) Source(9, 24) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -57,15 +56,15 @@ sourceFile:test.tsx 1 > > 2 > } -1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(10, 6) + SourceIndex(0) --- >>>} 1 >^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > >} -1 >Emitted(7, 2) Source(12, 2) + SourceIndex(0) +1 >Emitted(7, 2) Source(11, 2) + SourceIndex(0) --- >>>exports.AppComponent = AppComponent; 1-> @@ -76,7 +75,7 @@ sourceFile:test.tsx > return
; > } >} -1->Emitted(8, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(8, 37) Source(12, 2) + SourceIndex(0) +1->Emitted(8, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(8, 37) Source(11, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=test.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.errors.txt b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.errors.txt index e14f5f988f83f..c148a0b26585b 100644 --- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.errors.txt +++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.errors.txt @@ -5,7 +5,6 @@ tests/cases/compiler/test.tsx(13,5): error TS2304: Cannot find name 'React'. !!! error TS5067: Invalid value for 'jsxFactory'. 'Element.createElement=' is not a valid identifier or qualified-name. ==== tests/cases/compiler/Element.ts (0 errors) ==== - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.js b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.js index 9fc5799b11d96..8e4b1d8fc12f8 100644 --- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.js +++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryNotIdentifierOrQualifiedName.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.errors.txt b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.errors.txt index 1c33f3a7a5139..f0cf20e2e04e2 100644 --- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.errors.txt +++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.errors.txt @@ -5,7 +5,6 @@ tests/cases/compiler/test.tsx(13,5): error TS2304: Cannot find name 'React'. !!! error TS5067: Invalid value for 'jsxFactory'. 'id1 id2' is not a valid identifier or qualified-name. ==== tests/cases/compiler/Element.ts (0 errors) ==== - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.js b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.js index aa90c74cce5a7..6c7c95e36ff1a 100644 --- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.js +++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryNotIdentifierOrQualifiedName2.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.js b/tests/baselines/reference/jsxFactoryQualifiedName.js index ee747733799ba..63b45e878dd0f 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.js +++ b/tests/baselines/reference/jsxFactoryQualifiedName.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxFactoryQualifiedName.ts] //// //// [Element.ts] - declare namespace JSX { interface Element { name: string; diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.js.map b/tests/baselines/reference/jsxFactoryQualifiedName.js.map index 6c5dd8abf56bf..c4ac2d8e7e498 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.js.map +++ b/tests/baselines/reference/jsxFactoryQualifiedName.js.map @@ -1,3 +1,3 @@ //// [Element.js.map] -{"version":3,"file":"Element.js","sourceRoot":"","sources":["Element.ts"],"names":[],"mappings":";;AAaA,IAAiB,OAAO,CAUvB;AAVD,WAAiB,OAAO;IACpB,mBAA0B,EAAO;QAC7B,MAAM,CAAC,EAAE,CAAC,wBAAwB,KAAK,SAAS,CAAC;IACrD,CAAC;IAFe,iBAAS,YAExB,CAAA;IAED,uBAA8B,IAAW;QAErC,MAAM,CAAC,EACN,CAAA;IACL,CAAC;IAJe,qBAAa,gBAI5B,CAAA;AACL,CAAC,EAVgB,OAAO,GAAP,eAAO,KAAP,eAAO,QAUvB;AAEU,QAAA,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAEjD,qBAAqB,IAAY;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC"}//// [test.js.map] +{"version":3,"file":"Element.js","sourceRoot":"","sources":["Element.ts"],"names":[],"mappings":";;AAYA,IAAiB,OAAO,CAUvB;AAVD,WAAiB,OAAO;IACpB,mBAA0B,EAAO;QAC7B,MAAM,CAAC,EAAE,CAAC,wBAAwB,KAAK,SAAS,CAAC;IACrD,CAAC;IAFe,iBAAS,YAExB,CAAA;IAED,uBAA8B,IAAW;QAErC,MAAM,CAAC,EACN,CAAA;IACL,CAAC;IAJe,qBAAa,gBAI5B,CAAA;AACL,CAAC,EAVgB,OAAO,GAAP,eAAO,KAAP,eAAO,QAUvB;AAEU,QAAA,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAEjD,qBAAqB,IAAY;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC"}//// [test.js.map] {"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAAA,uCAAmC;AAEnC,IAAI,CAIH,CAAC;AAEF;IACC,IAAI;QACH,MAAM,CAAC;YACN,0CAAM,OAAO,EAAC,YAAY,GAAQ;YAClC,0CAAM,OAAO,EAAE,CAAC,CAAC,CAAE,CAAC,CAAC,GAAS;SAC9B,CAAC;IACH,CAAC;CACD"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.sourcemap.txt b/tests/baselines/reference/jsxFactoryQualifiedName.sourcemap.txt index 9831a9ab5fd6d..46a5945cc15e6 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryQualifiedName.sourcemap.txt @@ -16,8 +16,7 @@ sourceFile:Element.ts 3 > ^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^-> -1 > - >declare namespace JSX { +1 >declare namespace JSX { > interface Element { > name: string; > isIntrinsic: boolean; @@ -43,10 +42,10 @@ sourceFile:Element.ts > } > } > } -1 >Emitted(3, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(3, 5) Source(14, 18) + SourceIndex(0) -3 >Emitted(3, 12) Source(14, 25) + SourceIndex(0) -4 >Emitted(3, 13) Source(24, 2) + SourceIndex(0) +1 >Emitted(3, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(3, 5) Source(13, 18) + SourceIndex(0) +3 >Emitted(3, 12) Source(13, 25) + SourceIndex(0) +4 >Emitted(3, 13) Source(23, 2) + SourceIndex(0) --- >>>(function (Element) { 1-> @@ -56,9 +55,9 @@ sourceFile:Element.ts 1-> 2 >export namespace 3 > Element -1->Emitted(4, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(4, 12) Source(14, 18) + SourceIndex(0) -3 >Emitted(4, 19) Source(14, 25) + SourceIndex(0) +1->Emitted(4, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(4, 12) Source(13, 18) + SourceIndex(0) +3 >Emitted(4, 19) Source(13, 25) + SourceIndex(0) --- >>> function isElement(el) { 1->^^^^ @@ -69,9 +68,9 @@ sourceFile:Element.ts > 2 > export function isElement( 3 > el: any -1->Emitted(5, 5) Source(15, 5) + SourceIndex(0) -2 >Emitted(5, 24) Source(15, 31) + SourceIndex(0) -3 >Emitted(5, 26) Source(15, 38) + SourceIndex(0) +1->Emitted(5, 5) Source(14, 5) + SourceIndex(0) +2 >Emitted(5, 24) Source(14, 31) + SourceIndex(0) +3 >Emitted(5, 26) Source(14, 38) + SourceIndex(0) --- >>> return el.markAsChildOfRootElement !== undefined; 1->^^^^^^^^ @@ -93,15 +92,15 @@ sourceFile:Element.ts 7 > !== 8 > undefined 9 > ; -1->Emitted(6, 9) Source(16, 9) + SourceIndex(0) -2 >Emitted(6, 15) Source(16, 15) + SourceIndex(0) -3 >Emitted(6, 16) Source(16, 16) + SourceIndex(0) -4 >Emitted(6, 18) Source(16, 18) + SourceIndex(0) -5 >Emitted(6, 19) Source(16, 19) + SourceIndex(0) -6 >Emitted(6, 43) Source(16, 43) + SourceIndex(0) -7 >Emitted(6, 48) Source(16, 48) + SourceIndex(0) -8 >Emitted(6, 57) Source(16, 57) + SourceIndex(0) -9 >Emitted(6, 58) Source(16, 58) + SourceIndex(0) +1->Emitted(6, 9) Source(15, 9) + SourceIndex(0) +2 >Emitted(6, 15) Source(15, 15) + SourceIndex(0) +3 >Emitted(6, 16) Source(15, 16) + SourceIndex(0) +4 >Emitted(6, 18) Source(15, 18) + SourceIndex(0) +5 >Emitted(6, 19) Source(15, 19) + SourceIndex(0) +6 >Emitted(6, 43) Source(15, 43) + SourceIndex(0) +7 >Emitted(6, 48) Source(15, 48) + SourceIndex(0) +8 >Emitted(6, 57) Source(15, 57) + SourceIndex(0) +9 >Emitted(6, 58) Source(15, 58) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -110,8 +109,8 @@ sourceFile:Element.ts 1 > > 2 > } -1 >Emitted(7, 5) Source(17, 5) + SourceIndex(0) -2 >Emitted(7, 6) Source(17, 6) + SourceIndex(0) +1 >Emitted(7, 5) Source(16, 5) + SourceIndex(0) +2 >Emitted(7, 6) Source(16, 6) + SourceIndex(0) --- >>> Element.isElement = isElement; 1->^^^^ @@ -125,10 +124,10 @@ sourceFile:Element.ts > return el.markAsChildOfRootElement !== undefined; > } 4 > -1->Emitted(8, 5) Source(15, 21) + SourceIndex(0) -2 >Emitted(8, 22) Source(15, 30) + SourceIndex(0) -3 >Emitted(8, 34) Source(17, 6) + SourceIndex(0) -4 >Emitted(8, 35) Source(17, 6) + SourceIndex(0) +1->Emitted(8, 5) Source(14, 21) + SourceIndex(0) +2 >Emitted(8, 22) Source(14, 30) + SourceIndex(0) +3 >Emitted(8, 34) Source(16, 6) + SourceIndex(0) +4 >Emitted(8, 35) Source(16, 6) + SourceIndex(0) --- >>> function createElement(args) { 1->^^^^ @@ -139,9 +138,9 @@ sourceFile:Element.ts > 2 > export function createElement( 3 > args: any[] -1->Emitted(9, 5) Source(19, 5) + SourceIndex(0) -2 >Emitted(9, 28) Source(19, 35) + SourceIndex(0) -3 >Emitted(9, 32) Source(19, 46) + SourceIndex(0) +1->Emitted(9, 5) Source(18, 5) + SourceIndex(0) +2 >Emitted(9, 28) Source(18, 35) + SourceIndex(0) +3 >Emitted(9, 32) Source(18, 46) + SourceIndex(0) --- >>> return {}; 1 >^^^^^^^^ @@ -157,11 +156,11 @@ sourceFile:Element.ts 4 > { > } 5 > -1 >Emitted(10, 9) Source(21, 9) + SourceIndex(0) -2 >Emitted(10, 15) Source(21, 15) + SourceIndex(0) -3 >Emitted(10, 16) Source(21, 16) + SourceIndex(0) -4 >Emitted(10, 18) Source(22, 10) + SourceIndex(0) -5 >Emitted(10, 19) Source(22, 10) + SourceIndex(0) +1 >Emitted(10, 9) Source(20, 9) + SourceIndex(0) +2 >Emitted(10, 15) Source(20, 15) + SourceIndex(0) +3 >Emitted(10, 16) Source(20, 16) + SourceIndex(0) +4 >Emitted(10, 18) Source(21, 10) + SourceIndex(0) +5 >Emitted(10, 19) Source(21, 10) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -170,8 +169,8 @@ sourceFile:Element.ts 1 > > 2 > } -1 >Emitted(11, 5) Source(23, 5) + SourceIndex(0) -2 >Emitted(11, 6) Source(23, 6) + SourceIndex(0) +1 >Emitted(11, 5) Source(22, 5) + SourceIndex(0) +2 >Emitted(11, 6) Source(22, 6) + SourceIndex(0) --- >>> Element.createElement = createElement; 1->^^^^ @@ -187,10 +186,10 @@ sourceFile:Element.ts > } > } 4 > -1->Emitted(12, 5) Source(19, 21) + SourceIndex(0) -2 >Emitted(12, 26) Source(19, 34) + SourceIndex(0) -3 >Emitted(12, 42) Source(23, 6) + SourceIndex(0) -4 >Emitted(12, 43) Source(23, 6) + SourceIndex(0) +1->Emitted(12, 5) Source(18, 21) + SourceIndex(0) +2 >Emitted(12, 26) Source(18, 34) + SourceIndex(0) +3 >Emitted(12, 42) Source(22, 6) + SourceIndex(0) +4 >Emitted(12, 43) Source(22, 6) + SourceIndex(0) --- >>>})(Element = exports.Element || (exports.Element = {})); 1-> @@ -222,15 +221,15 @@ sourceFile:Element.ts > } > } > } -1->Emitted(13, 1) Source(24, 1) + SourceIndex(0) -2 >Emitted(13, 2) Source(24, 2) + SourceIndex(0) -3 >Emitted(13, 4) Source(14, 18) + SourceIndex(0) -4 >Emitted(13, 11) Source(14, 25) + SourceIndex(0) -5 >Emitted(13, 14) Source(14, 18) + SourceIndex(0) -6 >Emitted(13, 29) Source(14, 25) + SourceIndex(0) -7 >Emitted(13, 34) Source(14, 18) + SourceIndex(0) -8 >Emitted(13, 49) Source(14, 25) + SourceIndex(0) -9 >Emitted(13, 57) Source(24, 2) + SourceIndex(0) +1->Emitted(13, 1) Source(23, 1) + SourceIndex(0) +2 >Emitted(13, 2) Source(23, 2) + SourceIndex(0) +3 >Emitted(13, 4) Source(13, 18) + SourceIndex(0) +4 >Emitted(13, 11) Source(13, 25) + SourceIndex(0) +5 >Emitted(13, 14) Source(13, 18) + SourceIndex(0) +6 >Emitted(13, 29) Source(13, 25) + SourceIndex(0) +7 >Emitted(13, 34) Source(13, 18) + SourceIndex(0) +8 >Emitted(13, 49) Source(13, 25) + SourceIndex(0) +9 >Emitted(13, 57) Source(23, 2) + SourceIndex(0) --- >>>exports.createElement = Element.createElement; 1 > @@ -251,14 +250,14 @@ sourceFile:Element.ts 6 > . 7 > createElement 8 > ; -1 >Emitted(14, 1) Source(26, 12) + SourceIndex(0) -2 >Emitted(14, 9) Source(26, 12) + SourceIndex(0) -3 >Emitted(14, 22) Source(26, 25) + SourceIndex(0) -4 >Emitted(14, 25) Source(26, 28) + SourceIndex(0) -5 >Emitted(14, 32) Source(26, 35) + SourceIndex(0) -6 >Emitted(14, 33) Source(26, 36) + SourceIndex(0) -7 >Emitted(14, 46) Source(26, 49) + SourceIndex(0) -8 >Emitted(14, 47) Source(26, 50) + SourceIndex(0) +1 >Emitted(14, 1) Source(25, 12) + SourceIndex(0) +2 >Emitted(14, 9) Source(25, 12) + SourceIndex(0) +3 >Emitted(14, 22) Source(25, 25) + SourceIndex(0) +4 >Emitted(14, 25) Source(25, 28) + SourceIndex(0) +5 >Emitted(14, 32) Source(25, 35) + SourceIndex(0) +6 >Emitted(14, 33) Source(25, 36) + SourceIndex(0) +7 >Emitted(14, 46) Source(25, 49) + SourceIndex(0) +8 >Emitted(14, 47) Source(25, 50) + SourceIndex(0) --- >>>function toCamelCase(text) { 1 > @@ -270,9 +269,9 @@ sourceFile:Element.ts > 2 >function toCamelCase( 3 > text: string -1 >Emitted(15, 1) Source(28, 1) + SourceIndex(0) -2 >Emitted(15, 22) Source(28, 22) + SourceIndex(0) -3 >Emitted(15, 26) Source(28, 34) + SourceIndex(0) +1 >Emitted(15, 1) Source(27, 1) + SourceIndex(0) +2 >Emitted(15, 22) Source(27, 22) + SourceIndex(0) +3 >Emitted(15, 26) Source(27, 34) + SourceIndex(0) --- >>> return text[0].toLowerCase() + text.substring(1); 1->^^^^ @@ -312,24 +311,24 @@ sourceFile:Element.ts 16> 1 17> ) 18> ; -1->Emitted(16, 5) Source(29, 5) + SourceIndex(0) -2 >Emitted(16, 11) Source(29, 11) + SourceIndex(0) -3 >Emitted(16, 12) Source(29, 12) + SourceIndex(0) -4 >Emitted(16, 16) Source(29, 16) + SourceIndex(0) -5 >Emitted(16, 17) Source(29, 17) + SourceIndex(0) -6 >Emitted(16, 18) Source(29, 18) + SourceIndex(0) -7 >Emitted(16, 19) Source(29, 19) + SourceIndex(0) -8 >Emitted(16, 20) Source(29, 20) + SourceIndex(0) -9 >Emitted(16, 31) Source(29, 31) + SourceIndex(0) -10>Emitted(16, 33) Source(29, 33) + SourceIndex(0) -11>Emitted(16, 36) Source(29, 36) + SourceIndex(0) -12>Emitted(16, 40) Source(29, 40) + SourceIndex(0) -13>Emitted(16, 41) Source(29, 41) + SourceIndex(0) -14>Emitted(16, 50) Source(29, 50) + SourceIndex(0) -15>Emitted(16, 51) Source(29, 51) + SourceIndex(0) -16>Emitted(16, 52) Source(29, 52) + SourceIndex(0) -17>Emitted(16, 53) Source(29, 53) + SourceIndex(0) -18>Emitted(16, 54) Source(29, 54) + SourceIndex(0) +1->Emitted(16, 5) Source(28, 5) + SourceIndex(0) +2 >Emitted(16, 11) Source(28, 11) + SourceIndex(0) +3 >Emitted(16, 12) Source(28, 12) + SourceIndex(0) +4 >Emitted(16, 16) Source(28, 16) + SourceIndex(0) +5 >Emitted(16, 17) Source(28, 17) + SourceIndex(0) +6 >Emitted(16, 18) Source(28, 18) + SourceIndex(0) +7 >Emitted(16, 19) Source(28, 19) + SourceIndex(0) +8 >Emitted(16, 20) Source(28, 20) + SourceIndex(0) +9 >Emitted(16, 31) Source(28, 31) + SourceIndex(0) +10>Emitted(16, 33) Source(28, 33) + SourceIndex(0) +11>Emitted(16, 36) Source(28, 36) + SourceIndex(0) +12>Emitted(16, 40) Source(28, 40) + SourceIndex(0) +13>Emitted(16, 41) Source(28, 41) + SourceIndex(0) +14>Emitted(16, 50) Source(28, 50) + SourceIndex(0) +15>Emitted(16, 51) Source(28, 51) + SourceIndex(0) +16>Emitted(16, 52) Source(28, 52) + SourceIndex(0) +17>Emitted(16, 53) Source(28, 53) + SourceIndex(0) +18>Emitted(16, 54) Source(28, 54) + SourceIndex(0) --- >>>} 1 > @@ -338,8 +337,8 @@ sourceFile:Element.ts 1 > > 2 >} -1 >Emitted(17, 1) Source(30, 1) + SourceIndex(0) -2 >Emitted(17, 2) Source(30, 2) + SourceIndex(0) +1 >Emitted(17, 1) Source(29, 1) + SourceIndex(0) +2 >Emitted(17, 2) Source(29, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=Element.js.map=================================================================== JsFile: test.js diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.symbols b/tests/baselines/reference/jsxFactoryQualifiedName.symbols index f2579903d3e7d..f20470ebb6b37 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.symbols +++ b/tests/baselines/reference/jsxFactoryQualifiedName.symbols @@ -1,57 +1,56 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) interface Element { ->Element : Symbol(Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(Element, Decl(Element.ts, 0, 23)) name: string; ->name : Symbol(Element.name, Decl(Element.ts, 2, 23)) +>name : Symbol(Element.name, Decl(Element.ts, 1, 23)) isIntrinsic: boolean; ->isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 3, 21)) +>isIntrinsic : Symbol(Element.isIntrinsic, Decl(Element.ts, 2, 21)) isCustomElement: boolean; ->isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 4, 29)) +>isCustomElement : Symbol(Element.isCustomElement, Decl(Element.ts, 3, 29)) toString(renderId?: number): string; ->toString : Symbol(Element.toString, Decl(Element.ts, 5, 33)) ->renderId : Symbol(renderId, Decl(Element.ts, 6, 17)) +>toString : Symbol(Element.toString, Decl(Element.ts, 4, 33)) +>renderId : Symbol(renderId, Decl(Element.ts, 5, 17)) bindDOM(renderId?: number): number; ->bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 6, 44)) ->renderId : Symbol(renderId, Decl(Element.ts, 7, 16)) +>bindDOM : Symbol(Element.bindDOM, Decl(Element.ts, 5, 44)) +>renderId : Symbol(renderId, Decl(Element.ts, 6, 16)) resetComponent(): void; ->resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 7, 43)) +>resetComponent : Symbol(Element.resetComponent, Decl(Element.ts, 6, 43)) instantiateComponents(renderId?: number): number; ->instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 8, 31)) ->renderId : Symbol(renderId, Decl(Element.ts, 9, 30)) +>instantiateComponents : Symbol(Element.instantiateComponents, Decl(Element.ts, 7, 31)) +>renderId : Symbol(renderId, Decl(Element.ts, 8, 30)) props: any; ->props : Symbol(Element.props, Decl(Element.ts, 9, 57)) +>props : Symbol(Element.props, Decl(Element.ts, 8, 57)) } } export namespace Element { ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) export function isElement(el: any): el is JSX.Element { ->isElement : Symbol(isElement, Decl(Element.ts, 13, 26)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>isElement : Symbol(isElement, Decl(Element.ts, 12, 26)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >JSX : Symbol(JSX, Decl(Element.ts, 0, 0)) ->Element : Symbol(JSX.Element, Decl(Element.ts, 1, 23)) +>Element : Symbol(JSX.Element, Decl(Element.ts, 0, 23)) return el.markAsChildOfRootElement !== undefined; ->el : Symbol(el, Decl(Element.ts, 14, 30)) +>el : Symbol(el, Decl(Element.ts, 13, 30)) >undefined : Symbol(undefined) } export function createElement(args: any[]) { ->createElement : Symbol(createElement, Decl(Element.ts, 16, 5)) ->args : Symbol(args, Decl(Element.ts, 18, 34)) +>createElement : Symbol(createElement, Decl(Element.ts, 15, 5)) +>args : Symbol(args, Decl(Element.ts, 17, 34)) return { } @@ -59,21 +58,21 @@ export namespace Element { } export let createElement = Element.createElement; ->createElement : Symbol(createElement, Decl(Element.ts, 25, 10)) ->Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) ->Element : Symbol(Element, Decl(Element.ts, 12, 1)) ->createElement : Symbol(Element.createElement, Decl(Element.ts, 16, 5)) +>createElement : Symbol(createElement, Decl(Element.ts, 24, 10)) +>Element.createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) +>Element : Symbol(Element, Decl(Element.ts, 11, 1)) +>createElement : Symbol(Element.createElement, Decl(Element.ts, 15, 5)) function toCamelCase(text: string): string { ->toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 25, 49)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>toCamelCase : Symbol(toCamelCase, Decl(Element.ts, 24, 49)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) return text[0].toLowerCase() + text.substring(1); >text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) >text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) ->text : Symbol(text, Decl(Element.ts, 27, 21)) +>text : Symbol(text, Decl(Element.ts, 26, 21)) >substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --)) } diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.types b/tests/baselines/reference/jsxFactoryQualifiedName.types index 724aed319ec03..044b65222a906 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedName.types +++ b/tests/baselines/reference/jsxFactoryQualifiedName.types @@ -1,5 +1,4 @@ === tests/cases/compiler/Element.ts === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.errors.txt b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.errors.txt index 97a05d840f009..f7f066175a05c 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.errors.txt +++ b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.tsx(10,17): error TS2304: Cannot find name 'MyElement'. +tests/cases/compiler/test.tsx(9,17): error TS2304: Cannot find name 'MyElement'. ==== tests/cases/compiler/test.tsx (1 errors) ==== - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js index 510efc97f4a9a..c8a90a69cc2c3 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js +++ b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js @@ -1,5 +1,4 @@ //// [test.tsx] - declare module JSX { interface IntrinsicElements { [s: string]: any; diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js.map b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js.map index 1af641eb35159..5927e451e8ce5 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js.map +++ b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.js.map @@ -1,2 +1,2 @@ //// [test.js.map] -{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAOA;IACI,MAAM,CAAC,aAAa;QAChB,MAAM,CAAC,oCAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file +{"version":3,"file":"test.js","sourceRoot":"","sources":["test.tsx"],"names":[],"mappings":";;AAMA;IACI,MAAM,CAAC,aAAa;QAChB,MAAM,CAAC,oCAAO,CAAC;IACnB,CAAC;CACJ;AAJD,oCAIC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.sourcemap.txt b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.sourcemap.txt index 2f5270f370535..ee89acac0878e 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.sourcemap.txt +++ b/tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.sourcemap.txt @@ -13,15 +13,14 @@ sourceFile:test.tsx >>>class AppComponent { 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >declare module JSX { +1 >declare module JSX { > interface IntrinsicElements { > [s: string]: any; > } >} > > -1 >Emitted(3, 1) Source(8, 1) + SourceIndex(0) +1 >Emitted(3, 1) Source(7, 1) + SourceIndex(0) --- >>> render(createElement) { 1->^^^^ @@ -34,10 +33,10 @@ sourceFile:test.tsx 2 > render 3 > ( 4 > createElement -1->Emitted(4, 5) Source(9, 5) + SourceIndex(0) -2 >Emitted(4, 11) Source(9, 11) + SourceIndex(0) -3 >Emitted(4, 12) Source(9, 12) + SourceIndex(0) -4 >Emitted(4, 25) Source(9, 25) + SourceIndex(0) +1->Emitted(4, 5) Source(8, 5) + SourceIndex(0) +2 >Emitted(4, 11) Source(8, 11) + SourceIndex(0) +3 >Emitted(4, 12) Source(8, 12) + SourceIndex(0) +4 >Emitted(4, 25) Source(8, 25) + SourceIndex(0) --- >>> return MyElement.createElement("div", null); 1->^^^^^^^^ @@ -51,11 +50,11 @@ sourceFile:test.tsx 3 > 4 >
5 > ; -1->Emitted(5, 9) Source(10, 9) + SourceIndex(0) -2 >Emitted(5, 15) Source(10, 15) + SourceIndex(0) -3 >Emitted(5, 16) Source(10, 16) + SourceIndex(0) -4 >Emitted(5, 52) Source(10, 23) + SourceIndex(0) -5 >Emitted(5, 53) Source(10, 24) + SourceIndex(0) +1->Emitted(5, 9) Source(9, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(9, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(9, 16) + SourceIndex(0) +4 >Emitted(5, 52) Source(9, 23) + SourceIndex(0) +5 >Emitted(5, 53) Source(9, 24) + SourceIndex(0) --- >>> } 1 >^^^^ @@ -63,15 +62,15 @@ sourceFile:test.tsx 1 > > 2 > } -1 >Emitted(6, 5) Source(11, 5) + SourceIndex(0) -2 >Emitted(6, 6) Source(11, 6) + SourceIndex(0) +1 >Emitted(6, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(6, 6) Source(10, 6) + SourceIndex(0) --- >>>} 1 >^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > >} -1 >Emitted(7, 2) Source(12, 2) + SourceIndex(0) +1 >Emitted(7, 2) Source(11, 2) + SourceIndex(0) --- >>>exports.AppComponent = AppComponent; 1-> @@ -82,7 +81,7 @@ sourceFile:test.tsx > return
; > } >} -1->Emitted(8, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(8, 37) Source(12, 2) + SourceIndex(0) +1->Emitted(8, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(8, 37) Source(11, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=test.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.js b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.js index 267f3eaee5062..b549fb58a0a69 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.js +++ b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.js @@ -1,5 +1,4 @@ //// [index.tsx] - import "./jsx"; var skate: any; diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.symbols b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.symbols index 35879c81ca675..e06b8e345e80e 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.symbols +++ b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/index.tsx === - import "./jsx"; var skate: any; ->skate : Symbol(skate, Decl(index.tsx, 3, 3)) +>skate : Symbol(skate, Decl(index.tsx, 2, 3)) const React = { createElement: skate.h }; ->React : Symbol(React, Decl(index.tsx, 4, 5)) ->createElement : Symbol(createElement, Decl(index.tsx, 4, 15)) ->skate : Symbol(skate, Decl(index.tsx, 3, 3)) +>React : Symbol(React, Decl(index.tsx, 3, 5)) +>createElement : Symbol(createElement, Decl(index.tsx, 3, 15)) +>skate : Symbol(skate, Decl(index.tsx, 2, 3)) class Component { ->Component : Symbol(Component, Decl(index.tsx, 4, 41)) +>Component : Symbol(Component, Decl(index.tsx, 3, 41)) renderCallback() { ->renderCallback : Symbol(Component.renderCallback, Decl(index.tsx, 6, 17)) +>renderCallback : Symbol(Component.renderCallback, Decl(index.tsx, 5, 17)) return
test
; >div : Symbol(unknown) diff --git a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.types b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.types index 21fd4bae84b3a..6f6ae3f2d5849 100644 --- a/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.types +++ b/tests/baselines/reference/jsxFactoryQualifiedNameWithEs5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/index.tsx === - import "./jsx"; var skate: any; diff --git a/tests/baselines/reference/jsxImportInAttribute.js b/tests/baselines/reference/jsxImportInAttribute.js index 4b42ebe812d52..b249d88a6c2b4 100644 --- a/tests/baselines/reference/jsxImportInAttribute.js +++ b/tests/baselines/reference/jsxImportInAttribute.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxImportInAttribute.tsx] //// //// [component.d.ts] - declare module "Test" { export default class Text { } } diff --git a/tests/baselines/reference/jsxImportInAttribute.symbols b/tests/baselines/reference/jsxImportInAttribute.symbols index daf4dd110a344..44c746c7de6ee 100644 --- a/tests/baselines/reference/jsxImportInAttribute.symbols +++ b/tests/baselines/reference/jsxImportInAttribute.symbols @@ -13,9 +13,8 @@ let x = Test; // emit test_1.default >Test : Symbol(Test, Decl(consumer.tsx, 1, 6)) === tests/cases/compiler/component.d.ts === - declare module "Test" { export default class Text { } ->Text : Symbol(Text, Decl(component.d.ts, 1, 23)) +>Text : Symbol(Text, Decl(component.d.ts, 0, 23)) } diff --git a/tests/baselines/reference/jsxImportInAttribute.types b/tests/baselines/reference/jsxImportInAttribute.types index b4317f508c2b8..0c24f0156bac6 100644 --- a/tests/baselines/reference/jsxImportInAttribute.types +++ b/tests/baselines/reference/jsxImportInAttribute.types @@ -14,7 +14,6 @@ let x = Test; // emit test_1.default >Test : typeof Test === tests/cases/compiler/component.d.ts === - declare module "Test" { export default class Text { } >Text : Text diff --git a/tests/baselines/reference/jsxParsingError1.errors.txt b/tests/baselines/reference/jsxParsingError1.errors.txt index e769947dfa6cd..dec1228fd72e1 100644 --- a/tests/baselines/reference/jsxParsingError1.errors.txt +++ b/tests/baselines/reference/jsxParsingError1.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/jsx/file.tsx(12,36): error TS1005: '}' expected. -tests/cases/conformance/jsx/file.tsx(12,44): error TS1003: Identifier expected. -tests/cases/conformance/jsx/file.tsx(12,46): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/file.tsx(11,36): error TS1005: '}' expected. +tests/cases/conformance/jsx/file.tsx(11,44): error TS1003: Identifier expected. +tests/cases/conformance/jsx/file.tsx(11,46): error TS1161: Unterminated regular expression literal. ==== tests/cases/conformance/jsx/file.tsx (3 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/jsxParsingError1.js b/tests/baselines/reference/jsxParsingError1.js index 14b60afdde8d5..bf2d48b049126 100644 --- a/tests/baselines/reference/jsxParsingError1.js +++ b/tests/baselines/reference/jsxParsingError1.js @@ -1,5 +1,4 @@ //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/jsxParsingError2.errors.txt b/tests/baselines/reference/jsxParsingError2.errors.txt index 9d9922228f96e..cdf34baf4e1c0 100644 --- a/tests/baselines/reference/jsxParsingError2.errors.txt +++ b/tests/baselines/reference/jsxParsingError2.errors.txt @@ -13,7 +13,6 @@ tests/cases/conformance/jsx/Error5.tsx(3,1): error TS1005: 'elemA : Symbol(elemA, Decl(a.js, 1, 3)) +>elemA : Symbol(elemA, Decl(a.js, 0, 3)) === tests/cases/compiler/b.jsx === var elemB = {"test"}; diff --git a/tests/baselines/reference/jsxPreserveWithJsInput.types b/tests/baselines/reference/jsxPreserveWithJsInput.types index 4ae5c6aeed4cb..a38d884b4fa50 100644 --- a/tests/baselines/reference/jsxPreserveWithJsInput.types +++ b/tests/baselines/reference/jsxPreserveWithJsInput.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - var elemA = 42; >elemA : number >42 : 42 diff --git a/tests/baselines/reference/jsxReactTestSuite.js b/tests/baselines/reference/jsxReactTestSuite.js index 392f1736407be..3d11e01c51ac0 100644 --- a/tests/baselines/reference/jsxReactTestSuite.js +++ b/tests/baselines/reference/jsxReactTestSuite.js @@ -1,5 +1,4 @@ //// [jsxReactTestSuite.tsx] - declare var React: any; declare var Component:any; declare var Composite:any; diff --git a/tests/baselines/reference/jsxReactTestSuite.symbols b/tests/baselines/reference/jsxReactTestSuite.symbols index 36c0eef93a889..6ee9f629d4372 100644 --- a/tests/baselines/reference/jsxReactTestSuite.symbols +++ b/tests/baselines/reference/jsxReactTestSuite.symbols @@ -1,40 +1,39 @@ === tests/cases/conformance/jsx/jsxReactTestSuite.tsx === - declare var React: any; ->React : Symbol(React, Decl(jsxReactTestSuite.tsx, 1, 11)) +>React : Symbol(React, Decl(jsxReactTestSuite.tsx, 0, 11)) declare var Component:any; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) declare var Composite:any; ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) declare var Composite2:any; ->Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 4, 11)) +>Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 3, 11)) declare var Child:any; ->Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 5, 11)) +>Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 4, 11)) declare var Namespace:any; ->Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 6, 11)) +>Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 5, 11)) declare var foo: any; ->foo : Symbol(foo, Decl(jsxReactTestSuite.tsx, 7, 11)) +>foo : Symbol(foo, Decl(jsxReactTestSuite.tsx, 6, 11)) declare var bar: any; ->bar : Symbol(bar, Decl(jsxReactTestSuite.tsx, 8, 11)) +>bar : Symbol(bar, Decl(jsxReactTestSuite.tsx, 7, 11)) declare var y:any; ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 9, 11)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 8, 11)) declare var x:any; ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) declare var z:any; ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) declare var hasOwnProperty:any; ->hasOwnProperty : Symbol(hasOwnProperty, Decl(jsxReactTestSuite.tsx, 12, 11)) +>hasOwnProperty : Symbol(hasOwnProperty, Decl(jsxReactTestSuite.tsx, 11, 11))
text
; >div : Symbol(unknown) @@ -56,11 +55,11 @@ declare var hasOwnProperty:any; >div : Symbol(unknown) {foo}
{bar} ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->foo : Symbol(foo, Decl(jsxReactTestSuite.tsx, 7, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>foo : Symbol(foo, Decl(jsxReactTestSuite.tsx, 6, 11)) >br : Symbol(unknown) ->bar : Symbol(bar, Decl(jsxReactTestSuite.tsx, 8, 11)) ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>bar : Symbol(bar, Decl(jsxReactTestSuite.tsx, 7, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11))
>br : Symbol(unknown) @@ -70,48 +69,48 @@ declare var hasOwnProperty:any; ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) {this.props.children} ; ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) ->Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 4, 11)) +>Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 3, 11)) ; ->Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 2, 11)) var x = ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3))
div : Symbol(unknown) attr1={ ->attr1 : Symbol(attr1, Decl(jsxReactTestSuite.tsx, 36, 6)) +>attr1 : Symbol(attr1, Decl(jsxReactTestSuite.tsx, 35, 6)) "foo" + "bar" } attr2={ ->attr2 : Symbol(attr2, Decl(jsxReactTestSuite.tsx, 39, 5)) +>attr2 : Symbol(attr2, Decl(jsxReactTestSuite.tsx, 38, 5)) "foo" + "bar" + "baz" + "bug" } attr3={ ->attr3 : Symbol(attr3, Decl(jsxReactTestSuite.tsx, 44, 5)) +>attr3 : Symbol(attr3, Decl(jsxReactTestSuite.tsx, 43, 5)) "foo" + "bar" + "baz" + "bug" // Extra line here. } attr4="baz"> ->attr4 : Symbol(attr4, Decl(jsxReactTestSuite.tsx, 49, 5)) +>attr4 : Symbol(attr4, Decl(jsxReactTestSuite.tsx, 48, 5))
; >div : Symbol(unknown) @@ -147,13 +146,13 @@ var x = /* a multi-line comment */ attr1="foo"> ->attr1 : Symbol(attr1, Decl(jsxReactTestSuite.tsx, 68, 6)) +>attr1 : Symbol(attr1, Decl(jsxReactTestSuite.tsx, 67, 6)) span : Symbol(unknown) attr2="bar" ->attr2 : Symbol(attr2, Decl(jsxReactTestSuite.tsx, 72, 9)) +>attr2 : Symbol(attr2, Decl(jsxReactTestSuite.tsx, 71, 9)) />
@@ -174,78 +173,78 @@ var x = >hasOwnProperty : Symbol(unknown) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->constructor : Symbol(constructor, Decl(jsxReactTestSuite.tsx, 84, 10)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>constructor : Symbol(constructor, Decl(jsxReactTestSuite.tsx, 83, 10)) ; ->Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 6, 11)) +>Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 5, 11)) ; ->Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 6, 11)) +>Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 5, 11)) Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 90, 20)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 89, 20)) ={2 } z />; ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 91, 5)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 90, 5)) Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) {...this.props} sound="moo" />; ->sound : Symbol(sound, Decl(jsxReactTestSuite.tsx, 94, 19)) +>sound : Symbol(sound, Decl(jsxReactTestSuite.tsx, 93, 19)) ; >font-face : Symbol(unknown) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 98, 10)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 9, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 97, 10)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 8, 11)) ; >x-component : Symbol(unknown) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 104, 19)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 103, 19)) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 106, 20)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 106, 26)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 9, 11), Decl(jsxReactTestSuite.tsx, 34, 3)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 105, 20)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 105, 26)) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 108, 10)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 9, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 107, 10)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 8, 11)) ; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 111, 10)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 111, 16)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) ->Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 5, 11)) ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 110, 10)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 110, 16)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) +>Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 4, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) Text; ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) ->x : Symbol(x, Decl(jsxReactTestSuite.tsx, 113, 10)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) ->y : Symbol(y, Decl(jsxReactTestSuite.tsx, 113, 27)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) ->z : Symbol(z, Decl(jsxReactTestSuite.tsx, 113, 39)) ->Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 112, 10)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 112, 27)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 10, 11)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 112, 39)) +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 1, 11)) diff --git a/tests/baselines/reference/jsxReactTestSuite.types b/tests/baselines/reference/jsxReactTestSuite.types index bd120ba9df232..28ed2e5960adf 100644 --- a/tests/baselines/reference/jsxReactTestSuite.types +++ b/tests/baselines/reference/jsxReactTestSuite.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/jsxReactTestSuite.tsx === - declare var React: any; >React : any diff --git a/tests/baselines/reference/jsxViaImport.2.js b/tests/baselines/reference/jsxViaImport.2.js index 187ba545fb382..813df2de93812 100644 --- a/tests/baselines/reference/jsxViaImport.2.js +++ b/tests/baselines/reference/jsxViaImport.2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxViaImport.2.tsx] //// //// [component.d.ts] - declare module JSX { interface ElementAttributesProperty { props; } } diff --git a/tests/baselines/reference/jsxViaImport.2.symbols b/tests/baselines/reference/jsxViaImport.2.symbols index 5fb24088d2e85..40c38b9e4d587 100644 --- a/tests/baselines/reference/jsxViaImport.2.symbols +++ b/tests/baselines/reference/jsxViaImport.2.symbols @@ -5,9 +5,9 @@ import BaseComponent from 'BaseComponent'; class TestComponent extends React.Component { >TestComponent : Symbol(TestComponent, Decl(consumer.tsx, 1, 42)) ->React.Component : Symbol(React.Component, Decl(component.d.ts, 4, 22)) ->React : Symbol(React, Decl(component.d.ts, 3, 1)) ->Component : Symbol(React.Component, Decl(component.d.ts, 4, 22)) +>React.Component : Symbol(React.Component, Decl(component.d.ts, 3, 22)) +>React : Symbol(React, Decl(component.d.ts, 2, 1)) +>Component : Symbol(React.Component, Decl(component.d.ts, 3, 22)) render() { >render : Symbol(TestComponent.render, Decl(consumer.tsx, 2, 54)) @@ -18,27 +18,26 @@ class TestComponent extends React.Component { } === tests/cases/compiler/component.d.ts === - declare module JSX { >JSX : Symbol(JSX, Decl(component.d.ts, 0, 0)) interface ElementAttributesProperty { props; } ->ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(component.d.ts, 1, 20)) ->props : Symbol(ElementAttributesProperty.props, Decl(component.d.ts, 2, 39)) +>ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(component.d.ts, 0, 20)) +>props : Symbol(ElementAttributesProperty.props, Decl(component.d.ts, 1, 39)) } declare module React { ->React : Symbol(React, Decl(component.d.ts, 3, 1)) +>React : Symbol(React, Decl(component.d.ts, 2, 1)) class Component { } ->Component : Symbol(Component, Decl(component.d.ts, 4, 22)) ->T : Symbol(T, Decl(component.d.ts, 5, 18)) ->U : Symbol(U, Decl(component.d.ts, 5, 20)) +>Component : Symbol(Component, Decl(component.d.ts, 3, 22)) +>T : Symbol(T, Decl(component.d.ts, 4, 18)) +>U : Symbol(U, Decl(component.d.ts, 4, 20)) } declare module "BaseComponent" { export default class extends React.Component { ->React.Component : Symbol(React.Component, Decl(component.d.ts, 4, 22)) ->React : Symbol(React, Decl(component.d.ts, 3, 1)) ->Component : Symbol(React.Component, Decl(component.d.ts, 4, 22)) +>React.Component : Symbol(React.Component, Decl(component.d.ts, 3, 22)) +>React : Symbol(React, Decl(component.d.ts, 2, 1)) +>Component : Symbol(React.Component, Decl(component.d.ts, 3, 22)) } } diff --git a/tests/baselines/reference/jsxViaImport.2.types b/tests/baselines/reference/jsxViaImport.2.types index c1e418c6b3221..396c4d381a04b 100644 --- a/tests/baselines/reference/jsxViaImport.2.types +++ b/tests/baselines/reference/jsxViaImport.2.types @@ -19,7 +19,6 @@ class TestComponent extends React.Component { } === tests/cases/compiler/component.d.ts === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/jsxViaImport.errors.txt b/tests/baselines/reference/jsxViaImport.errors.txt index 8fa22809a44e8..fef730db4596e 100644 --- a/tests/baselines/reference/jsxViaImport.errors.txt +++ b/tests/baselines/reference/jsxViaImport.errors.txt @@ -13,7 +13,6 @@ tests/cases/compiler/consumer.tsx(5,17): error TS2604: JSX element type 'BaseCom } ==== tests/cases/compiler/component.d.ts (0 errors) ==== - declare module JSX { interface ElementAttributesProperty { props; } } diff --git a/tests/baselines/reference/jsxViaImport.js b/tests/baselines/reference/jsxViaImport.js index 3b291a347747e..cfbbb9eb456ce 100644 --- a/tests/baselines/reference/jsxViaImport.js +++ b/tests/baselines/reference/jsxViaImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/jsxViaImport.tsx] //// //// [component.d.ts] - declare module JSX { interface ElementAttributesProperty { props; } } diff --git a/tests/baselines/reference/keepImportsInDts1.js b/tests/baselines/reference/keepImportsInDts1.js index 3f945a5ebc35b..e58702de2293a 100644 --- a/tests/baselines/reference/keepImportsInDts1.js +++ b/tests/baselines/reference/keepImportsInDts1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/keepImportsInDts1.ts] //// //// [test.d.ts] - export {}; //// [main.ts] import "test" diff --git a/tests/baselines/reference/keepImportsInDts1.symbols b/tests/baselines/reference/keepImportsInDts1.symbols index 92bd84c20880e..0d0e7b9ccfd8c 100644 --- a/tests/baselines/reference/keepImportsInDts1.symbols +++ b/tests/baselines/reference/keepImportsInDts1.symbols @@ -1,6 +1,5 @@ === c:/test.d.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== c:/app/main.ts === import "test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts1.types b/tests/baselines/reference/keepImportsInDts1.types index 92bd84c20880e..0d0e7b9ccfd8c 100644 --- a/tests/baselines/reference/keepImportsInDts1.types +++ b/tests/baselines/reference/keepImportsInDts1.types @@ -1,6 +1,5 @@ === c:/test.d.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== c:/app/main.ts === import "test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts2.js b/tests/baselines/reference/keepImportsInDts2.js index acd75a00c87a7..6e659f489dafb 100644 --- a/tests/baselines/reference/keepImportsInDts2.js +++ b/tests/baselines/reference/keepImportsInDts2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/keepImportsInDts2.ts] //// //// [test.ts] - export {}; //// [main.ts] import "./folder/test" diff --git a/tests/baselines/reference/keepImportsInDts2.symbols b/tests/baselines/reference/keepImportsInDts2.symbols index ce6f4c7c1685d..a18db585da9d4 100644 --- a/tests/baselines/reference/keepImportsInDts2.symbols +++ b/tests/baselines/reference/keepImportsInDts2.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/folder/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== tests/cases/compiler/main.ts === import "./folder/test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts2.types b/tests/baselines/reference/keepImportsInDts2.types index ce6f4c7c1685d..a18db585da9d4 100644 --- a/tests/baselines/reference/keepImportsInDts2.types +++ b/tests/baselines/reference/keepImportsInDts2.types @@ -1,6 +1,5 @@ === tests/cases/compiler/folder/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== tests/cases/compiler/main.ts === import "./folder/test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts3.js b/tests/baselines/reference/keepImportsInDts3.js index aec2e544e2f96..6589c675eaa40 100644 --- a/tests/baselines/reference/keepImportsInDts3.js +++ b/tests/baselines/reference/keepImportsInDts3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/keepImportsInDts3.ts] //// //// [test.ts] - export {}; //// [main.ts] import "test" diff --git a/tests/baselines/reference/keepImportsInDts3.symbols b/tests/baselines/reference/keepImportsInDts3.symbols index 29c4a4e44b42f..552c6ff0be61b 100644 --- a/tests/baselines/reference/keepImportsInDts3.symbols +++ b/tests/baselines/reference/keepImportsInDts3.symbols @@ -1,6 +1,5 @@ === c:/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== c:/app/main.ts === import "test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts3.types b/tests/baselines/reference/keepImportsInDts3.types index 29c4a4e44b42f..552c6ff0be61b 100644 --- a/tests/baselines/reference/keepImportsInDts3.types +++ b/tests/baselines/reference/keepImportsInDts3.types @@ -1,6 +1,5 @@ === c:/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== c:/app/main.ts === import "test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts4.js b/tests/baselines/reference/keepImportsInDts4.js index 3a959bcbbacbd..41c07e836684e 100644 --- a/tests/baselines/reference/keepImportsInDts4.js +++ b/tests/baselines/reference/keepImportsInDts4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/keepImportsInDts4.ts] //// //// [test.ts] - export {}; //// [main.ts] import "./folder/test" diff --git a/tests/baselines/reference/keepImportsInDts4.symbols b/tests/baselines/reference/keepImportsInDts4.symbols index ce6f4c7c1685d..a18db585da9d4 100644 --- a/tests/baselines/reference/keepImportsInDts4.symbols +++ b/tests/baselines/reference/keepImportsInDts4.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/folder/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== tests/cases/compiler/main.ts === import "./folder/test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keepImportsInDts4.types b/tests/baselines/reference/keepImportsInDts4.types index ce6f4c7c1685d..a18db585da9d4 100644 --- a/tests/baselines/reference/keepImportsInDts4.types +++ b/tests/baselines/reference/keepImportsInDts4.types @@ -1,6 +1,5 @@ === tests/cases/compiler/folder/test.ts === - -No type information for this code.export {}; +export {}; No type information for this code.=== tests/cases/compiler/main.ts === import "./folder/test" No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/keyofAndForIn.js b/tests/baselines/reference/keyofAndForIn.js index 0debf28b75ea2..4a880fe7d4d9c 100644 --- a/tests/baselines/reference/keyofAndForIn.js +++ b/tests/baselines/reference/keyofAndForIn.js @@ -1,5 +1,4 @@ //// [keyofAndForIn.ts] - // Repro from #12513 function f1(obj: { [P in K]: T }, k: K) { diff --git a/tests/baselines/reference/keyofAndForIn.symbols b/tests/baselines/reference/keyofAndForIn.symbols index 36b5d3e2d7272..11a6d8547983b 100644 --- a/tests/baselines/reference/keyofAndForIn.symbols +++ b/tests/baselines/reference/keyofAndForIn.symbols @@ -1,125 +1,124 @@ === tests/cases/conformance/types/keyof/keyofAndForIn.ts === - // Repro from #12513 function f1(obj: { [P in K]: T }, k: K) { >f1 : Symbol(f1, Decl(keyofAndForIn.ts, 0, 0)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 3, 12)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 3, 29)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 3, 41)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 3, 12)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 3, 29)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 3, 54)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 3, 12)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 2, 12)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 2, 29)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 2, 41)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 2, 12)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 2, 29)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 2, 54)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 2, 12)) const b = k in obj; ->b : Symbol(b, Decl(keyofAndForIn.ts, 4, 9)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 3, 54)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) +>b : Symbol(b, Decl(keyofAndForIn.ts, 3, 9)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 2, 54)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) let k1: K; ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 5, 7)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 3, 12)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 4, 7)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 2, 12)) for (k1 in obj) { ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 5, 7)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 4, 7)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) let x1 = obj[k1]; ->x1 : Symbol(x1, Decl(keyofAndForIn.ts, 7, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 5, 7)) +>x1 : Symbol(x1, Decl(keyofAndForIn.ts, 6, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 4, 7)) } for (let k2 in obj) { ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 9, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 8, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) let x2 = obj[k2]; ->x2 : Symbol(x2, Decl(keyofAndForIn.ts, 10, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 3, 33)) ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 9, 12)) +>x2 : Symbol(x2, Decl(keyofAndForIn.ts, 9, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 2, 33)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 8, 12)) } } function f2(obj: { [P in keyof T]: T[P] }, k: keyof T) { ->f2 : Symbol(f2, Decl(keyofAndForIn.ts, 12, 1)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 14, 23)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 14, 23)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 14, 45)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) +>f2 : Symbol(f2, Decl(keyofAndForIn.ts, 11, 1)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 13, 23)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 13, 23)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 13, 45)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) const b = k in obj; ->b : Symbol(b, Decl(keyofAndForIn.ts, 15, 9)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 14, 45)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) +>b : Symbol(b, Decl(keyofAndForIn.ts, 14, 9)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 13, 45)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) let k1: keyof T; ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 16, 7)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 14, 12)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 15, 7)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 13, 12)) for (k1 in obj) { ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 16, 7)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 15, 7)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) let x1 = obj[k1]; ->x1 : Symbol(x1, Decl(keyofAndForIn.ts, 18, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 16, 7)) +>x1 : Symbol(x1, Decl(keyofAndForIn.ts, 17, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 15, 7)) } for (let k2 in obj) { ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 20, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 19, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) let x2 = obj[k2]; ->x2 : Symbol(x2, Decl(keyofAndForIn.ts, 21, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 14, 15)) ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 20, 12)) +>x2 : Symbol(x2, Decl(keyofAndForIn.ts, 20, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 13, 15)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 19, 12)) } } function f3(obj: { [P in K]: T[P] }, k: K) { ->f3 : Symbol(f3, Decl(keyofAndForIn.ts, 23, 1)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 25, 12)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 25, 14)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 25, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 25, 42)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 25, 14)) ->T : Symbol(T, Decl(keyofAndForIn.ts, 25, 12)) ->P : Symbol(P, Decl(keyofAndForIn.ts, 25, 42)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 25, 58)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 25, 14)) +>f3 : Symbol(f3, Decl(keyofAndForIn.ts, 22, 1)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 24, 12)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 24, 14)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 24, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 24, 42)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 24, 14)) +>T : Symbol(T, Decl(keyofAndForIn.ts, 24, 12)) +>P : Symbol(P, Decl(keyofAndForIn.ts, 24, 42)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 24, 58)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 24, 14)) const b = k in obj; ->b : Symbol(b, Decl(keyofAndForIn.ts, 26, 9)) ->k : Symbol(k, Decl(keyofAndForIn.ts, 25, 58)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) +>b : Symbol(b, Decl(keyofAndForIn.ts, 25, 9)) +>k : Symbol(k, Decl(keyofAndForIn.ts, 24, 58)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) let k1: K; ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 27, 7)) ->K : Symbol(K, Decl(keyofAndForIn.ts, 25, 14)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 26, 7)) +>K : Symbol(K, Decl(keyofAndForIn.ts, 24, 14)) for (k1 in obj) { ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 27, 7)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 26, 7)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) let x1 = obj[k1]; ->x1 : Symbol(x1, Decl(keyofAndForIn.ts, 29, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) ->k1 : Symbol(k1, Decl(keyofAndForIn.ts, 27, 7)) +>x1 : Symbol(x1, Decl(keyofAndForIn.ts, 28, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) +>k1 : Symbol(k1, Decl(keyofAndForIn.ts, 26, 7)) } for (let k2 in obj) { ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 31, 12)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 30, 12)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) let x2 = obj[k2]; ->x2 : Symbol(x2, Decl(keyofAndForIn.ts, 32, 11)) ->obj : Symbol(obj, Decl(keyofAndForIn.ts, 25, 34)) ->k2 : Symbol(k2, Decl(keyofAndForIn.ts, 31, 12)) +>x2 : Symbol(x2, Decl(keyofAndForIn.ts, 31, 11)) +>obj : Symbol(obj, Decl(keyofAndForIn.ts, 24, 34)) +>k2 : Symbol(k2, Decl(keyofAndForIn.ts, 30, 12)) } } diff --git a/tests/baselines/reference/keyofAndForIn.types b/tests/baselines/reference/keyofAndForIn.types index 5e992e5d26103..d20f1a5707071 100644 --- a/tests/baselines/reference/keyofAndForIn.types +++ b/tests/baselines/reference/keyofAndForIn.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/keyof/keyofAndForIn.ts === - // Repro from #12513 function f1(obj: { [P in K]: T }, k: K) { diff --git a/tests/baselines/reference/keyofAndIndexedAccess.js b/tests/baselines/reference/keyofAndIndexedAccess.js index 2b1b22d35953f..cbd9549b1637b 100644 --- a/tests/baselines/reference/keyofAndIndexedAccess.js +++ b/tests/baselines/reference/keyofAndIndexedAccess.js @@ -1,5 +1,4 @@ //// [keyofAndIndexedAccess.ts] - class Shape { name: string; width: number; diff --git a/tests/baselines/reference/keyofAndIndexedAccess.symbols b/tests/baselines/reference/keyofAndIndexedAccess.symbols index d5c4660d474bd..6d7e886d26c2d 100644 --- a/tests/baselines/reference/keyofAndIndexedAccess.symbols +++ b/tests/baselines/reference/keyofAndIndexedAccess.symbols @@ -1,1965 +1,1964 @@ === tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts === - class Shape { >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) name: string; ->name : Symbol(Shape.name, Decl(keyofAndIndexedAccess.ts, 1, 13)) +>name : Symbol(Shape.name, Decl(keyofAndIndexedAccess.ts, 0, 13)) width: number; ->width : Symbol(Shape.width, Decl(keyofAndIndexedAccess.ts, 2, 17)) +>width : Symbol(Shape.width, Decl(keyofAndIndexedAccess.ts, 1, 17)) height: number; ->height : Symbol(Shape.height, Decl(keyofAndIndexedAccess.ts, 3, 18)) +>height : Symbol(Shape.height, Decl(keyofAndIndexedAccess.ts, 2, 18)) visible: boolean; ->visible : Symbol(Shape.visible, Decl(keyofAndIndexedAccess.ts, 4, 19)) +>visible : Symbol(Shape.visible, Decl(keyofAndIndexedAccess.ts, 3, 19)) } class TaggedShape extends Shape { ->TaggedShape : Symbol(TaggedShape, Decl(keyofAndIndexedAccess.ts, 6, 1)) +>TaggedShape : Symbol(TaggedShape, Decl(keyofAndIndexedAccess.ts, 5, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) tag: string; ->tag : Symbol(TaggedShape.tag, Decl(keyofAndIndexedAccess.ts, 8, 33)) +>tag : Symbol(TaggedShape.tag, Decl(keyofAndIndexedAccess.ts, 7, 33)) } class Item { ->Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 10, 1)) +>Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 9, 1)) name: string; ->name : Symbol(Item.name, Decl(keyofAndIndexedAccess.ts, 12, 12)) +>name : Symbol(Item.name, Decl(keyofAndIndexedAccess.ts, 11, 12)) price: number; ->price : Symbol(Item.price, Decl(keyofAndIndexedAccess.ts, 13, 17)) +>price : Symbol(Item.price, Decl(keyofAndIndexedAccess.ts, 12, 17)) } class Options { ->Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 15, 1)) +>Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 14, 1)) visible: "yes" | "no"; ->visible : Symbol(Options.visible, Decl(keyofAndIndexedAccess.ts, 17, 15)) +>visible : Symbol(Options.visible, Decl(keyofAndIndexedAccess.ts, 16, 15)) } type Dictionary = { [x: string]: T }; ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 21, 16)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 21, 24)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 21, 16)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 20, 16)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 20, 24)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 20, 16)) type NumericallyIndexed = { [x: number]: T }; ->NumericallyIndexed : Symbol(NumericallyIndexed, Decl(keyofAndIndexedAccess.ts, 21, 40)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 22, 24)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 22, 32)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 22, 24)) +>NumericallyIndexed : Symbol(NumericallyIndexed, Decl(keyofAndIndexedAccess.ts, 20, 40)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 21, 24)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 21, 32)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 21, 24)) const enum E { A, B, C } ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->A : Symbol(E.A, Decl(keyofAndIndexedAccess.ts, 24, 14)) ->B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 24, 17)) ->C : Symbol(E.C, Decl(keyofAndIndexedAccess.ts, 24, 20)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>A : Symbol(E.A, Decl(keyofAndIndexedAccess.ts, 23, 14)) +>B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 23, 17)) +>C : Symbol(E.C, Decl(keyofAndIndexedAccess.ts, 23, 20)) type K00 = keyof any; // string ->K00 : Symbol(K00, Decl(keyofAndIndexedAccess.ts, 24, 24)) +>K00 : Symbol(K00, Decl(keyofAndIndexedAccess.ts, 23, 24)) type K01 = keyof string; // "toString" | "charAt" | ... ->K01 : Symbol(K01, Decl(keyofAndIndexedAccess.ts, 26, 21)) +>K01 : Symbol(K01, Decl(keyofAndIndexedAccess.ts, 25, 21)) type K02 = keyof number; // "toString" | "toFixed" | "toExponential" | ... ->K02 : Symbol(K02, Decl(keyofAndIndexedAccess.ts, 27, 24)) +>K02 : Symbol(K02, Decl(keyofAndIndexedAccess.ts, 26, 24)) type K03 = keyof boolean; // "valueOf" ->K03 : Symbol(K03, Decl(keyofAndIndexedAccess.ts, 28, 24)) +>K03 : Symbol(K03, Decl(keyofAndIndexedAccess.ts, 27, 24)) type K04 = keyof void; // never ->K04 : Symbol(K04, Decl(keyofAndIndexedAccess.ts, 29, 25)) +>K04 : Symbol(K04, Decl(keyofAndIndexedAccess.ts, 28, 25)) type K05 = keyof undefined; // never ->K05 : Symbol(K05, Decl(keyofAndIndexedAccess.ts, 30, 22)) +>K05 : Symbol(K05, Decl(keyofAndIndexedAccess.ts, 29, 22)) type K06 = keyof null; // never ->K06 : Symbol(K06, Decl(keyofAndIndexedAccess.ts, 31, 27)) +>K06 : Symbol(K06, Decl(keyofAndIndexedAccess.ts, 30, 27)) type K07 = keyof never; // never ->K07 : Symbol(K07, Decl(keyofAndIndexedAccess.ts, 32, 22)) +>K07 : Symbol(K07, Decl(keyofAndIndexedAccess.ts, 31, 22)) type K10 = keyof Shape; // "name" | "width" | "height" | "visible" ->K10 : Symbol(K10, Decl(keyofAndIndexedAccess.ts, 33, 23)) +>K10 : Symbol(K10, Decl(keyofAndIndexedAccess.ts, 32, 23)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type K11 = keyof Shape[]; // "length" | "toString" | ... ->K11 : Symbol(K11, Decl(keyofAndIndexedAccess.ts, 35, 23)) +>K11 : Symbol(K11, Decl(keyofAndIndexedAccess.ts, 34, 23)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type K12 = keyof Dictionary; // string ->K12 : Symbol(K12, Decl(keyofAndIndexedAccess.ts, 36, 25)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>K12 : Symbol(K12, Decl(keyofAndIndexedAccess.ts, 35, 25)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type K13 = keyof {}; // never ->K13 : Symbol(K13, Decl(keyofAndIndexedAccess.ts, 37, 35)) +>K13 : Symbol(K13, Decl(keyofAndIndexedAccess.ts, 36, 35)) type K14 = keyof Object; // "constructor" | "toString" | ... ->K14 : Symbol(K14, Decl(keyofAndIndexedAccess.ts, 38, 20)) +>K14 : Symbol(K14, Decl(keyofAndIndexedAccess.ts, 37, 20)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type K15 = keyof E; // "toString" | "toFixed" | "toExponential" | ... ->K15 : Symbol(K15, Decl(keyofAndIndexedAccess.ts, 39, 24)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) +>K15 : Symbol(K15, Decl(keyofAndIndexedAccess.ts, 38, 24)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) type K16 = keyof [string, number]; // "0" | "1" | "length" | "toString" | ... ->K16 : Symbol(K16, Decl(keyofAndIndexedAccess.ts, 40, 19)) +>K16 : Symbol(K16, Decl(keyofAndIndexedAccess.ts, 39, 19)) type K17 = keyof (Shape | Item); // "name" ->K17 : Symbol(K17, Decl(keyofAndIndexedAccess.ts, 41, 34)) +>K17 : Symbol(K17, Decl(keyofAndIndexedAccess.ts, 40, 34)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 10, 1)) +>Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 9, 1)) type K18 = keyof (Shape & Item); // "name" | "width" | "height" | "visible" | "price" ->K18 : Symbol(K18, Decl(keyofAndIndexedAccess.ts, 42, 32)) +>K18 : Symbol(K18, Decl(keyofAndIndexedAccess.ts, 41, 32)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 10, 1)) +>Item : Symbol(Item, Decl(keyofAndIndexedAccess.ts, 9, 1)) type K19 = keyof NumericallyIndexed // never ->K19 : Symbol(K19, Decl(keyofAndIndexedAccess.ts, 43, 32)) ->NumericallyIndexed : Symbol(NumericallyIndexed, Decl(keyofAndIndexedAccess.ts, 21, 40)) +>K19 : Symbol(K19, Decl(keyofAndIndexedAccess.ts, 42, 32)) +>NumericallyIndexed : Symbol(NumericallyIndexed, Decl(keyofAndIndexedAccess.ts, 20, 40)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type KeyOf = keyof T; ->KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 44, 42)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 46, 11)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 46, 11)) +>KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 43, 42)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 45, 11)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 45, 11)) type K20 = KeyOf; // "name" | "width" | "height" | "visible" ->K20 : Symbol(K20, Decl(keyofAndIndexedAccess.ts, 46, 24)) ->KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 44, 42)) +>K20 : Symbol(K20, Decl(keyofAndIndexedAccess.ts, 45, 24)) +>KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 43, 42)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type K21 = KeyOf>; // string ->K21 : Symbol(K21, Decl(keyofAndIndexedAccess.ts, 48, 24)) ->KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 44, 42)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>K21 : Symbol(K21, Decl(keyofAndIndexedAccess.ts, 47, 24)) +>KeyOf : Symbol(KeyOf, Decl(keyofAndIndexedAccess.ts, 43, 42)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type NAME = "name"; ->NAME : Symbol(NAME, Decl(keyofAndIndexedAccess.ts, 49, 36)) +>NAME : Symbol(NAME, Decl(keyofAndIndexedAccess.ts, 48, 36)) type WIDTH_OR_HEIGHT = "width" | "height"; ->WIDTH_OR_HEIGHT : Symbol(WIDTH_OR_HEIGHT, Decl(keyofAndIndexedAccess.ts, 51, 19)) +>WIDTH_OR_HEIGHT : Symbol(WIDTH_OR_HEIGHT, Decl(keyofAndIndexedAccess.ts, 50, 19)) type Q10 = Shape["name"]; // string ->Q10 : Symbol(Q10, Decl(keyofAndIndexedAccess.ts, 52, 42)) +>Q10 : Symbol(Q10, Decl(keyofAndIndexedAccess.ts, 51, 42)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q11 = Shape["width" | "height"]; // number ->Q11 : Symbol(Q11, Decl(keyofAndIndexedAccess.ts, 54, 25)) +>Q11 : Symbol(Q11, Decl(keyofAndIndexedAccess.ts, 53, 25)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q12 = Shape["name" | "visible"]; // string | boolean ->Q12 : Symbol(Q12, Decl(keyofAndIndexedAccess.ts, 55, 37)) +>Q12 : Symbol(Q12, Decl(keyofAndIndexedAccess.ts, 54, 37)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q20 = Shape[NAME]; // string ->Q20 : Symbol(Q20, Decl(keyofAndIndexedAccess.ts, 56, 37)) +>Q20 : Symbol(Q20, Decl(keyofAndIndexedAccess.ts, 55, 37)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->NAME : Symbol(NAME, Decl(keyofAndIndexedAccess.ts, 49, 36)) +>NAME : Symbol(NAME, Decl(keyofAndIndexedAccess.ts, 48, 36)) type Q21 = Shape[WIDTH_OR_HEIGHT]; // number ->Q21 : Symbol(Q21, Decl(keyofAndIndexedAccess.ts, 58, 23)) +>Q21 : Symbol(Q21, Decl(keyofAndIndexedAccess.ts, 57, 23)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->WIDTH_OR_HEIGHT : Symbol(WIDTH_OR_HEIGHT, Decl(keyofAndIndexedAccess.ts, 51, 19)) +>WIDTH_OR_HEIGHT : Symbol(WIDTH_OR_HEIGHT, Decl(keyofAndIndexedAccess.ts, 50, 19)) type Q30 = [string, number][0]; // string ->Q30 : Symbol(Q30, Decl(keyofAndIndexedAccess.ts, 59, 34)) +>Q30 : Symbol(Q30, Decl(keyofAndIndexedAccess.ts, 58, 34)) type Q31 = [string, number][1]; // number ->Q31 : Symbol(Q31, Decl(keyofAndIndexedAccess.ts, 61, 31)) +>Q31 : Symbol(Q31, Decl(keyofAndIndexedAccess.ts, 60, 31)) type Q32 = [string, number][2]; // string | number ->Q32 : Symbol(Q32, Decl(keyofAndIndexedAccess.ts, 62, 31)) +>Q32 : Symbol(Q32, Decl(keyofAndIndexedAccess.ts, 61, 31)) type Q33 = [string, number][E.A]; // string ->Q33 : Symbol(Q33, Decl(keyofAndIndexedAccess.ts, 63, 31)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->A : Symbol(E.A, Decl(keyofAndIndexedAccess.ts, 24, 14)) +>Q33 : Symbol(Q33, Decl(keyofAndIndexedAccess.ts, 62, 31)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>A : Symbol(E.A, Decl(keyofAndIndexedAccess.ts, 23, 14)) type Q34 = [string, number][E.B]; // number ->Q34 : Symbol(Q34, Decl(keyofAndIndexedAccess.ts, 64, 33)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 24, 17)) +>Q34 : Symbol(Q34, Decl(keyofAndIndexedAccess.ts, 63, 33)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 23, 17)) type Q35 = [string, number][E.C]; // string | number ->Q35 : Symbol(Q35, Decl(keyofAndIndexedAccess.ts, 65, 33)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->C : Symbol(E.C, Decl(keyofAndIndexedAccess.ts, 24, 20)) +>Q35 : Symbol(Q35, Decl(keyofAndIndexedAccess.ts, 64, 33)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>C : Symbol(E.C, Decl(keyofAndIndexedAccess.ts, 23, 20)) type Q36 = [string, number]["0"]; // string ->Q36 : Symbol(Q36, Decl(keyofAndIndexedAccess.ts, 66, 33)) +>Q36 : Symbol(Q36, Decl(keyofAndIndexedAccess.ts, 65, 33)) type Q37 = [string, number]["1"]; // string ->Q37 : Symbol(Q37, Decl(keyofAndIndexedAccess.ts, 67, 33)) +>Q37 : Symbol(Q37, Decl(keyofAndIndexedAccess.ts, 66, 33)) type Q40 = (Shape | Options)["visible"]; // boolean | "yes" | "no" ->Q40 : Symbol(Q40, Decl(keyofAndIndexedAccess.ts, 68, 33)) +>Q40 : Symbol(Q40, Decl(keyofAndIndexedAccess.ts, 67, 33)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 15, 1)) +>Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 14, 1)) type Q41 = (Shape & Options)["visible"]; // true & "yes" | true & "no" | false & "yes" | false & "no" ->Q41 : Symbol(Q41, Decl(keyofAndIndexedAccess.ts, 70, 40)) +>Q41 : Symbol(Q41, Decl(keyofAndIndexedAccess.ts, 69, 40)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 15, 1)) +>Options : Symbol(Options, Decl(keyofAndIndexedAccess.ts, 14, 1)) type Q50 = Dictionary["howdy"]; // Shape ->Q50 : Symbol(Q50, Decl(keyofAndIndexedAccess.ts, 71, 40)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>Q50 : Symbol(Q50, Decl(keyofAndIndexedAccess.ts, 70, 40)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q51 = Dictionary[123]; // Shape ->Q51 : Symbol(Q51, Decl(keyofAndIndexedAccess.ts, 73, 38)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>Q51 : Symbol(Q51, Decl(keyofAndIndexedAccess.ts, 72, 38)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) type Q52 = Dictionary[E.B]; // Shape ->Q52 : Symbol(Q52, Decl(keyofAndIndexedAccess.ts, 74, 34)) ->Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 19, 1)) +>Q52 : Symbol(Q52, Decl(keyofAndIndexedAccess.ts, 73, 34)) +>Dictionary : Symbol(Dictionary, Decl(keyofAndIndexedAccess.ts, 18, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 22, 48)) ->B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 24, 17)) +>E : Symbol(E, Decl(keyofAndIndexedAccess.ts, 21, 48)) +>B : Symbol(E.B, Decl(keyofAndIndexedAccess.ts, 23, 17)) declare let cond: boolean; ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) function getProperty(obj: T, key: K) { ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 79, 21)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 79, 23)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 79, 21)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 79, 43)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 79, 21)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 79, 50)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 79, 23)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 78, 21)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 78, 23)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 78, 21)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 78, 43)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 78, 21)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 78, 50)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 78, 23)) return obj[key]; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 79, 43)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 79, 50)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 78, 43)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 78, 50)) } function setProperty(obj: T, key: K, value: T[K]) { ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 83, 21)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 83, 23)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 83, 21)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 83, 43)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 83, 21)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 83, 50)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 83, 23)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 83, 58)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 83, 21)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 83, 23)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 82, 21)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 82, 23)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 82, 21)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 82, 43)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 82, 21)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 82, 50)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 82, 23)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 82, 58)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 82, 21)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 82, 23)) obj[key] = value; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 83, 43)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 83, 50)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 83, 58)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 82, 43)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 82, 50)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 82, 58)) } function f10(shape: Shape) { ->f10 : Symbol(f10, Decl(keyofAndIndexedAccess.ts, 85, 1)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) +>f10 : Symbol(f10, Decl(keyofAndIndexedAccess.ts, 84, 1)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let name = getProperty(shape, "name"); // string ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 88, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 87, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) let widthOrHeight = getProperty(shape, cond ? "width" : "height"); // number ->widthOrHeight : Symbol(widthOrHeight, Decl(keyofAndIndexedAccess.ts, 89, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>widthOrHeight : Symbol(widthOrHeight, Decl(keyofAndIndexedAccess.ts, 88, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) let nameOrVisible = getProperty(shape, cond ? "name" : "visible"); // string | boolean ->nameOrVisible : Symbol(nameOrVisible, Decl(keyofAndIndexedAccess.ts, 90, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>nameOrVisible : Symbol(nameOrVisible, Decl(keyofAndIndexedAccess.ts, 89, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) setProperty(shape, "name", "rectangle"); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) setProperty(shape, cond ? "width" : "height", 10); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) setProperty(shape, cond ? "name" : "visible", true); // Technically not safe ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 87, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 86, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) } function f11(a: Shape[]) { ->f11 : Symbol(f11, Decl(keyofAndIndexedAccess.ts, 94, 1)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 96, 13)) +>f11 : Symbol(f11, Decl(keyofAndIndexedAccess.ts, 93, 1)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 95, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let len = getProperty(a, "length"); // number ->len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 97, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 96, 13)) +>len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 96, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 95, 13)) setProperty(a, "length", len); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 96, 13)) ->len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 97, 7)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 95, 13)) +>len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 96, 7)) } function f12(t: [Shape, boolean]) { ->f12 : Symbol(f12, Decl(keyofAndIndexedAccess.ts, 99, 1)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 101, 13)) +>f12 : Symbol(f12, Decl(keyofAndIndexedAccess.ts, 98, 1)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 100, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let len = getProperty(t, "length"); ->len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 102, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 101, 13)) +>len : Symbol(len, Decl(keyofAndIndexedAccess.ts, 101, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 100, 13)) let s2 = getProperty(t, "0"); // Shape ->s2 : Symbol(s2, Decl(keyofAndIndexedAccess.ts, 103, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 101, 13)) +>s2 : Symbol(s2, Decl(keyofAndIndexedAccess.ts, 102, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 100, 13)) let b2 = getProperty(t, "1"); // boolean ->b2 : Symbol(b2, Decl(keyofAndIndexedAccess.ts, 104, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 101, 13)) +>b2 : Symbol(b2, Decl(keyofAndIndexedAccess.ts, 103, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 100, 13)) } function f13(foo: any, bar: any) { ->f13 : Symbol(f13, Decl(keyofAndIndexedAccess.ts, 105, 1)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 107, 13)) ->bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 107, 22)) +>f13 : Symbol(f13, Decl(keyofAndIndexedAccess.ts, 104, 1)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 106, 13)) +>bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 106, 22)) let x = getProperty(foo, "x"); // any ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 108, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 107, 13)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 107, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 106, 13)) let y = getProperty(foo, "100"); // any ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 109, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 107, 13)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 108, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 106, 13)) let z = getProperty(foo, bar); // any ->z : Symbol(z, Decl(keyofAndIndexedAccess.ts, 110, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 107, 13)) ->bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 107, 22)) +>z : Symbol(z, Decl(keyofAndIndexedAccess.ts, 109, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 106, 13)) +>bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 106, 22)) } class Component { ->Component : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 111, 1)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) +>Component : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 110, 1)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) props: PropType; ->props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) +>props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) getProperty(key: K) { ->getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 115, 16)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 115, 42)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 115, 16)) +>getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 114, 16)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 114, 42)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 114, 16)) return this.props[key]; ->this.props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->this : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 111, 1)) ->props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 115, 42)) +>this.props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>this : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 110, 1)) +>props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 114, 42)) } setProperty(key: K, value: PropType[K]) { ->setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 118, 16)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 118, 42)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 118, 16)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 118, 49)) ->PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 113, 16)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 118, 16)) +>setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 117, 16)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 117, 42)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 117, 16)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 117, 49)) +>PropType : Symbol(PropType, Decl(keyofAndIndexedAccess.ts, 112, 16)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 117, 16)) this.props[key] = value; ->this.props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->this : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 111, 1)) ->props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 113, 27)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 118, 42)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 118, 49)) +>this.props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>this : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 110, 1)) +>props : Symbol(Component.props, Decl(keyofAndIndexedAccess.ts, 112, 27)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 117, 42)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 117, 49)) } } function f20(component: Component) { ->f20 : Symbol(f20, Decl(keyofAndIndexedAccess.ts, 121, 1)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->Component : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 111, 1)) +>f20 : Symbol(f20, Decl(keyofAndIndexedAccess.ts, 120, 1)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>Component : Symbol(Component, Decl(keyofAndIndexedAccess.ts, 110, 1)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let name = component.getProperty("name"); // string ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 124, 7)) ->component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 123, 7)) +>component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) let widthOrHeight = component.getProperty(cond ? "width" : "height"); // number ->widthOrHeight : Symbol(widthOrHeight, Decl(keyofAndIndexedAccess.ts, 125, 7)) ->component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>widthOrHeight : Symbol(widthOrHeight, Decl(keyofAndIndexedAccess.ts, 124, 7)) +>component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) let nameOrVisible = component.getProperty(cond ? "name" : "visible"); // string | boolean ->nameOrVisible : Symbol(nameOrVisible, Decl(keyofAndIndexedAccess.ts, 126, 7)) ->component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 114, 20)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>nameOrVisible : Symbol(nameOrVisible, Decl(keyofAndIndexedAccess.ts, 125, 7)) +>component.getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>getProperty : Symbol(Component.getProperty, Decl(keyofAndIndexedAccess.ts, 113, 20)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) component.setProperty("name", "rectangle"); ->component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) +>component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) component.setProperty(cond ? "width" : "height", 10) ->component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) component.setProperty(cond ? "name" : "visible", true); // Technically not safe ->component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 123, 13)) ->setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 117, 5)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>component.setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>component : Symbol(component, Decl(keyofAndIndexedAccess.ts, 122, 13)) +>setProperty : Symbol(Component.setProperty, Decl(keyofAndIndexedAccess.ts, 116, 5)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) } function pluck(array: T[], key: K) { ->pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 130, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 132, 15)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 132, 17)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 132, 15)) ->array : Symbol(array, Decl(keyofAndIndexedAccess.ts, 132, 37)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 132, 15)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 132, 48)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 132, 17)) +>pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 129, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 131, 15)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 131, 17)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 131, 15)) +>array : Symbol(array, Decl(keyofAndIndexedAccess.ts, 131, 37)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 131, 15)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 131, 48)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 131, 17)) return array.map(x => x[key]); >array.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->array : Symbol(array, Decl(keyofAndIndexedAccess.ts, 132, 37)) +>array : Symbol(array, Decl(keyofAndIndexedAccess.ts, 131, 37)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 133, 21)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 133, 21)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 132, 48)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 132, 21)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 132, 21)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 131, 48)) } function f30(shapes: Shape[]) { ->f30 : Symbol(f30, Decl(keyofAndIndexedAccess.ts, 134, 1)) ->shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 136, 13)) +>f30 : Symbol(f30, Decl(keyofAndIndexedAccess.ts, 133, 1)) +>shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 135, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) let names = pluck(shapes, "name"); // string[] ->names : Symbol(names, Decl(keyofAndIndexedAccess.ts, 137, 7)) ->pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 130, 1)) ->shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 136, 13)) +>names : Symbol(names, Decl(keyofAndIndexedAccess.ts, 136, 7)) +>pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 129, 1)) +>shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 135, 13)) let widths = pluck(shapes, "width"); // number[] ->widths : Symbol(widths, Decl(keyofAndIndexedAccess.ts, 138, 7)) ->pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 130, 1)) ->shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 136, 13)) +>widths : Symbol(widths, Decl(keyofAndIndexedAccess.ts, 137, 7)) +>pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 129, 1)) +>shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 135, 13)) let nameOrVisibles = pluck(shapes, cond ? "name" : "visible"); // (string | boolean)[] ->nameOrVisibles : Symbol(nameOrVisibles, Decl(keyofAndIndexedAccess.ts, 139, 7)) ->pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 130, 1)) ->shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 136, 13)) ->cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 77, 11)) +>nameOrVisibles : Symbol(nameOrVisibles, Decl(keyofAndIndexedAccess.ts, 138, 7)) +>pluck : Symbol(pluck, Decl(keyofAndIndexedAccess.ts, 129, 1)) +>shapes : Symbol(shapes, Decl(keyofAndIndexedAccess.ts, 135, 13)) +>cond : Symbol(cond, Decl(keyofAndIndexedAccess.ts, 76, 11)) } function f31(key: K) { ->f31 : Symbol(f31, Decl(keyofAndIndexedAccess.ts, 140, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 142, 13)) +>f31 : Symbol(f31, Decl(keyofAndIndexedAccess.ts, 139, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 141, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 142, 36)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 142, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 141, 36)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 141, 13)) const shape: Shape = { name: "foo", width: 5, height: 10, visible: true }; ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 143, 9)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 142, 9)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 143, 26)) ->width : Symbol(width, Decl(keyofAndIndexedAccess.ts, 143, 39)) ->height : Symbol(height, Decl(keyofAndIndexedAccess.ts, 143, 49)) ->visible : Symbol(visible, Decl(keyofAndIndexedAccess.ts, 143, 61)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 142, 26)) +>width : Symbol(width, Decl(keyofAndIndexedAccess.ts, 142, 39)) +>height : Symbol(height, Decl(keyofAndIndexedAccess.ts, 142, 49)) +>visible : Symbol(visible, Decl(keyofAndIndexedAccess.ts, 142, 61)) return shape[key]; // Shape[K] ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 143, 9)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 142, 36)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 142, 9)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 141, 36)) } function f32(key: K) { ->f32 : Symbol(f32, Decl(keyofAndIndexedAccess.ts, 145, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 147, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 147, 43)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 147, 13)) +>f32 : Symbol(f32, Decl(keyofAndIndexedAccess.ts, 144, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 146, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 146, 43)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 146, 13)) const shape: Shape = { name: "foo", width: 5, height: 10, visible: true }; ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 148, 9)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 147, 9)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 148, 26)) ->width : Symbol(width, Decl(keyofAndIndexedAccess.ts, 148, 39)) ->height : Symbol(height, Decl(keyofAndIndexedAccess.ts, 148, 49)) ->visible : Symbol(visible, Decl(keyofAndIndexedAccess.ts, 148, 61)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 147, 26)) +>width : Symbol(width, Decl(keyofAndIndexedAccess.ts, 147, 39)) +>height : Symbol(height, Decl(keyofAndIndexedAccess.ts, 147, 49)) +>visible : Symbol(visible, Decl(keyofAndIndexedAccess.ts, 147, 61)) return shape[key]; // Shape[K] ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 148, 9)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 147, 43)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 147, 9)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 146, 43)) } function f33(shape: S, key: K) { ->f33 : Symbol(f33, Decl(keyofAndIndexedAccess.ts, 150, 1)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 152, 13)) +>f33 : Symbol(f33, Decl(keyofAndIndexedAccess.ts, 149, 1)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 151, 13)) >Shape : Symbol(Shape, Decl(keyofAndIndexedAccess.ts, 0, 0)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 152, 29)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 152, 13)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 152, 49)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 152, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 152, 58)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 152, 29)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 151, 29)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 151, 13)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 151, 49)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 151, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 151, 58)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 151, 29)) let name = getProperty(shape, "name"); ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 153, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 152, 49)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 152, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 151, 49)) let prop = getProperty(shape, key); ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 154, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 152, 49)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 152, 58)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 153, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>shape : Symbol(shape, Decl(keyofAndIndexedAccess.ts, 151, 49)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 151, 58)) return prop; ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 154, 7)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 153, 7)) } function f34(ts: TaggedShape) { ->f34 : Symbol(f34, Decl(keyofAndIndexedAccess.ts, 156, 1)) ->ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 158, 13)) ->TaggedShape : Symbol(TaggedShape, Decl(keyofAndIndexedAccess.ts, 6, 1)) +>f34 : Symbol(f34, Decl(keyofAndIndexedAccess.ts, 155, 1)) +>ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 157, 13)) +>TaggedShape : Symbol(TaggedShape, Decl(keyofAndIndexedAccess.ts, 5, 1)) let tag1 = f33(ts, "tag"); ->tag1 : Symbol(tag1, Decl(keyofAndIndexedAccess.ts, 159, 7)) ->f33 : Symbol(f33, Decl(keyofAndIndexedAccess.ts, 150, 1)) ->ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 158, 13)) +>tag1 : Symbol(tag1, Decl(keyofAndIndexedAccess.ts, 158, 7)) +>f33 : Symbol(f33, Decl(keyofAndIndexedAccess.ts, 149, 1)) +>ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 157, 13)) let tag2 = getProperty(ts, "tag"); ->tag2 : Symbol(tag2, Decl(keyofAndIndexedAccess.ts, 160, 7)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 158, 13)) +>tag2 : Symbol(tag2, Decl(keyofAndIndexedAccess.ts, 159, 7)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>ts : Symbol(ts, Decl(keyofAndIndexedAccess.ts, 157, 13)) } class C { ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) public x: string; ->x : Symbol(C.x, Decl(keyofAndIndexedAccess.ts, 163, 9)) +>x : Symbol(C.x, Decl(keyofAndIndexedAccess.ts, 162, 9)) protected y: string; ->y : Symbol(C.y, Decl(keyofAndIndexedAccess.ts, 164, 21)) +>y : Symbol(C.y, Decl(keyofAndIndexedAccess.ts, 163, 21)) private z: string; ->z : Symbol(C.z, Decl(keyofAndIndexedAccess.ts, 165, 24)) +>z : Symbol(C.z, Decl(keyofAndIndexedAccess.ts, 164, 24)) } // Indexed access expressions have always permitted access to private and protected members. // For consistency we also permit such access in indexed access types. function f40(c: C) { ->f40 : Symbol(f40, Decl(keyofAndIndexedAccess.ts, 167, 1)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 171, 13)) ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>f40 : Symbol(f40, Decl(keyofAndIndexedAccess.ts, 166, 1)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 170, 13)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) type X = C["x"]; ->X : Symbol(X, Decl(keyofAndIndexedAccess.ts, 171, 20)) ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>X : Symbol(X, Decl(keyofAndIndexedAccess.ts, 170, 20)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) type Y = C["y"]; ->Y : Symbol(Y, Decl(keyofAndIndexedAccess.ts, 172, 20)) ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>Y : Symbol(Y, Decl(keyofAndIndexedAccess.ts, 171, 20)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) type Z = C["z"]; ->Z : Symbol(Z, Decl(keyofAndIndexedAccess.ts, 173, 20)) ->C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 161, 1)) +>Z : Symbol(Z, Decl(keyofAndIndexedAccess.ts, 172, 20)) +>C : Symbol(C, Decl(keyofAndIndexedAccess.ts, 160, 1)) let x: X = c["x"]; ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 175, 7)) ->X : Symbol(X, Decl(keyofAndIndexedAccess.ts, 171, 20)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 171, 13)) ->"x" : Symbol(C.x, Decl(keyofAndIndexedAccess.ts, 163, 9)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 174, 7)) +>X : Symbol(X, Decl(keyofAndIndexedAccess.ts, 170, 20)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 170, 13)) +>"x" : Symbol(C.x, Decl(keyofAndIndexedAccess.ts, 162, 9)) let y: Y = c["y"]; ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 176, 7)) ->Y : Symbol(Y, Decl(keyofAndIndexedAccess.ts, 172, 20)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 171, 13)) ->"y" : Symbol(C.y, Decl(keyofAndIndexedAccess.ts, 164, 21)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 175, 7)) +>Y : Symbol(Y, Decl(keyofAndIndexedAccess.ts, 171, 20)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 170, 13)) +>"y" : Symbol(C.y, Decl(keyofAndIndexedAccess.ts, 163, 21)) let z: Z = c["z"]; ->z : Symbol(z, Decl(keyofAndIndexedAccess.ts, 177, 7)) ->Z : Symbol(Z, Decl(keyofAndIndexedAccess.ts, 173, 20)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 171, 13)) ->"z" : Symbol(C.z, Decl(keyofAndIndexedAccess.ts, 165, 24)) +>z : Symbol(z, Decl(keyofAndIndexedAccess.ts, 176, 7)) +>Z : Symbol(Z, Decl(keyofAndIndexedAccess.ts, 172, 20)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 170, 13)) +>"z" : Symbol(C.z, Decl(keyofAndIndexedAccess.ts, 164, 24)) } function f50(k: keyof T, s: string) { ->f50 : Symbol(f50, Decl(keyofAndIndexedAccess.ts, 178, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 180, 13)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 180, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 180, 13)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 180, 27)) +>f50 : Symbol(f50, Decl(keyofAndIndexedAccess.ts, 177, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 179, 13)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 179, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 179, 13)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 179, 27)) const x1 = s as keyof T; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 181, 9)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 180, 27)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 180, 13)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 180, 9)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 179, 27)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 179, 13)) const x2 = k as string; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 182, 9)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 180, 16)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 181, 9)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 179, 16)) } function f51(k: K, s: string) { ->f51 : Symbol(f51, Decl(keyofAndIndexedAccess.ts, 183, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 185, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 185, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 185, 13)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 185, 35)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 185, 15)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 185, 40)) +>f51 : Symbol(f51, Decl(keyofAndIndexedAccess.ts, 182, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 184, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 184, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 184, 13)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 184, 35)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 184, 15)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 184, 40)) const x1 = s as keyof T; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 186, 9)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 185, 40)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 185, 13)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 185, 9)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 184, 40)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 184, 13)) const x2 = k as string; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 187, 9)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 185, 35)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 186, 9)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 184, 35)) } function f52(obj: { [x: string]: boolean }, k: keyof T, s: string, n: number) { ->f52 : Symbol(f52, Decl(keyofAndIndexedAccess.ts, 188, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 190, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 190, 16)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 190, 24)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 190, 46)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 190, 13)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 190, 58)) ->n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 190, 69)) +>f52 : Symbol(f52, Decl(keyofAndIndexedAccess.ts, 187, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 189, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 189, 16)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 189, 24)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 189, 46)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 189, 13)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 189, 58)) +>n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 189, 69)) const x1 = obj[s]; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 191, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 190, 16)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 190, 58)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 190, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 189, 16)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 189, 58)) const x2 = obj[n]; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 192, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 190, 16)) ->n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 190, 69)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 191, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 189, 16)) +>n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 189, 69)) const x3 = obj[k]; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 193, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 190, 16)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 190, 46)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 192, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 189, 16)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 189, 46)) } function f53(obj: { [x: string]: boolean }, k: K, s: string, n: number) { ->f53 : Symbol(f53, Decl(keyofAndIndexedAccess.ts, 194, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 196, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 196, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 196, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 196, 35)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 196, 43)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 196, 65)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 196, 15)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 196, 71)) ->n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 196, 82)) +>f53 : Symbol(f53, Decl(keyofAndIndexedAccess.ts, 193, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 195, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 195, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 195, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 195, 35)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 195, 43)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 195, 65)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 195, 15)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 195, 71)) +>n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 195, 82)) const x1 = obj[s]; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 197, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 196, 35)) ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 196, 71)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 196, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 195, 35)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 195, 71)) const x2 = obj[n]; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 198, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 196, 35)) ->n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 196, 82)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 197, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 195, 35)) +>n : Symbol(n, Decl(keyofAndIndexedAccess.ts, 195, 82)) const x3 = obj[k]; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 199, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 196, 35)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 196, 65)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 198, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 195, 35)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 195, 65)) } function f54(obj: T, key: keyof T) { ->f54 : Symbol(f54, Decl(keyofAndIndexedAccess.ts, 200, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 202, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 202, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 202, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 202, 23)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 202, 13)) +>f54 : Symbol(f54, Decl(keyofAndIndexedAccess.ts, 199, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 201, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 201, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 201, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 201, 23)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 201, 13)) for (let s in obj[key]) { ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 203, 12)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 202, 16)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 202, 23)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 202, 12)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 201, 16)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 201, 23)) } const b = "foo" in obj[key]; ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 205, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 202, 16)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 202, 23)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 204, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 201, 16)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 201, 23)) } function f55(obj: T, key: K) { ->f55 : Symbol(f55, Decl(keyofAndIndexedAccess.ts, 206, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 208, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 208, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 208, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 208, 35)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 208, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 208, 42)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 208, 15)) +>f55 : Symbol(f55, Decl(keyofAndIndexedAccess.ts, 205, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 207, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 207, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 207, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 207, 35)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 207, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 207, 42)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 207, 15)) for (let s in obj[key]) { ->s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 209, 12)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 208, 35)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 208, 42)) +>s : Symbol(s, Decl(keyofAndIndexedAccess.ts, 208, 12)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 207, 35)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 207, 42)) } const b = "foo" in obj[key]; ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 211, 9)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 208, 35)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 208, 42)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 210, 9)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 207, 35)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 207, 42)) } function f60(source: T, target: T) { ->f60 : Symbol(f60, Decl(keyofAndIndexedAccess.ts, 212, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 214, 13)) ->source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 214, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 214, 13)) ->target : Symbol(target, Decl(keyofAndIndexedAccess.ts, 214, 26)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 214, 13)) +>f60 : Symbol(f60, Decl(keyofAndIndexedAccess.ts, 211, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 213, 13)) +>source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 213, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 213, 13)) +>target : Symbol(target, Decl(keyofAndIndexedAccess.ts, 213, 26)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 213, 13)) for (let k in source) { ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 215, 12)) ->source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 214, 16)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 214, 12)) +>source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 213, 16)) target[k] = source[k]; ->target : Symbol(target, Decl(keyofAndIndexedAccess.ts, 214, 26)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 215, 12)) ->source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 214, 16)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 215, 12)) +>target : Symbol(target, Decl(keyofAndIndexedAccess.ts, 213, 26)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 214, 12)) +>source : Symbol(source, Decl(keyofAndIndexedAccess.ts, 213, 16)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 214, 12)) } } function f70(func: (k1: keyof (T | U), k2: keyof (T & U)) => void) { ->f70 : Symbol(f70, Decl(keyofAndIndexedAccess.ts, 218, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 220, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 220, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 220, 22)) ->k1 : Symbol(k1, Decl(keyofAndIndexedAccess.ts, 220, 26)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 220, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 220, 22)) ->k2 : Symbol(k2, Decl(keyofAndIndexedAccess.ts, 220, 44)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 220, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 220, 22)) +>f70 : Symbol(f70, Decl(keyofAndIndexedAccess.ts, 217, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 219, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 219, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 219, 22)) +>k1 : Symbol(k1, Decl(keyofAndIndexedAccess.ts, 219, 26)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 219, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 219, 22)) +>k2 : Symbol(k2, Decl(keyofAndIndexedAccess.ts, 219, 44)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 219, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 219, 22)) func<{ a: any, b: any }, { a: any, c: any }>('a', 'a'); ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 220, 13)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 219, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 220, 10)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 220, 18)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 220, 30)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 220, 38)) + + func<{ a: any, b: any }, { a: any, c: any }>('a', 'b'); +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 219, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 221, 10)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 221, 18)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 221, 30)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 221, 38)) - func<{ a: any, b: any }, { a: any, c: any }>('a', 'b'); ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 220, 13)) + func<{ a: any, b: any }, { a: any, c: any }>('a', 'c'); +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 219, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 222, 10)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 222, 18)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 222, 30)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 222, 38)) - - func<{ a: any, b: any }, { a: any, c: any }>('a', 'c'); ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 220, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 223, 10)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 223, 18)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 223, 30)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 223, 38)) } function f71(func: (x: T, y: U) => Partial) { ->f71 : Symbol(f71, Decl(keyofAndIndexedAccess.ts, 224, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 226, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 226, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 226, 22)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 26)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 226, 20)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 226, 31)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 226, 22)) +>f71 : Symbol(f71, Decl(keyofAndIndexedAccess.ts, 223, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 225, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 225, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 225, 22)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 225, 26)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 225, 20)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 225, 31)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 225, 22)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 226, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 226, 22)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 225, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 225, 22)) let x = func({ a: 1, b: "hello" }, { c: true }); ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 227, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 226, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 227, 18)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 227, 24)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 227, 40)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 225, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 226, 18)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 226, 24)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 226, 40)) x.a; // number | undefined >x.a : Symbol(a) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 227, 7)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 7)) >a : Symbol(a) x.b; // string | undefined >x.b : Symbol(b) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 227, 7)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 7)) >b : Symbol(b) x.c; // boolean | undefined >x.c : Symbol(c) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 227, 7)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 226, 7)) >c : Symbol(c) } function f72(func: (x: T, y: U, k: K) => (T & U)[K]) { ->f72 : Symbol(f72, Decl(keyofAndIndexedAccess.ts, 231, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 233, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 233, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 233, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 233, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 233, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 233, 22)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 233, 55)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 233, 20)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 233, 60)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 233, 22)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 233, 66)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 233, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 233, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 233, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 233, 25)) +>f72 : Symbol(f72, Decl(keyofAndIndexedAccess.ts, 230, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 232, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 232, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 232, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 232, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 232, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 232, 22)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 232, 55)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 232, 20)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 232, 60)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 232, 22)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 232, 66)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 232, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 232, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 232, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 232, 25)) let a = func({ a: 1, b: "hello" }, { c: true }, 'a'); // number ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 234, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 233, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 233, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 232, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 233, 18)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 233, 24)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 233, 40)) + + let b = func({ a: 1, b: "hello" }, { c: true }, 'b'); // string +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 234, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 232, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 234, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 234, 24)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 234, 40)) - let b = func({ a: 1, b: "hello" }, { c: true }, 'b'); // string ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 235, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 233, 13)) + let c = func({ a: 1, b: "hello" }, { c: true }, 'c'); // boolean +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 235, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 232, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 235, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 235, 24)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 235, 40)) - - let c = func({ a: 1, b: "hello" }, { c: true }, 'c'); // boolean ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 236, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 233, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 236, 18)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 236, 24)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 236, 40)) } function f73(func: (x: T, y: U, k: K) => (T & U)[K]) { ->f73 : Symbol(f73, Decl(keyofAndIndexedAccess.ts, 237, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 239, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 239, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 239, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 239, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 239, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 239, 22)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 239, 51)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 239, 20)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 239, 56)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 239, 22)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 239, 62)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 239, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 239, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 239, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 239, 25)) +>f73 : Symbol(f73, Decl(keyofAndIndexedAccess.ts, 236, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 238, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 238, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 238, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 238, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 238, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 238, 22)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 238, 51)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 238, 20)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 238, 56)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 238, 22)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 238, 62)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 238, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 238, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 238, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 238, 25)) let a = func({ a: 1, b: "hello" }, { c: true }, 'a'); // number ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 240, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 239, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 239, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 238, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 239, 18)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 239, 24)) +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 239, 40)) + + let b = func({ a: 1, b: "hello" }, { c: true }, 'b'); // string +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 240, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 238, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 240, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 240, 24)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 240, 40)) - let b = func({ a: 1, b: "hello" }, { c: true }, 'b'); // string ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 241, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 239, 13)) + let c = func({ a: 1, b: "hello" }, { c: true }, 'c'); // boolean +>c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 241, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 238, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 241, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 241, 24)) >c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 241, 40)) - - let c = func({ a: 1, b: "hello" }, { c: true }, 'c'); // boolean ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 242, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 239, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 242, 18)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 242, 24)) ->c : Symbol(c, Decl(keyofAndIndexedAccess.ts, 242, 40)) } function f74(func: (x: T, y: U, k: K) => (T | U)[K]) { ->f74 : Symbol(f74, Decl(keyofAndIndexedAccess.ts, 243, 1)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 245, 13)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 245, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 245, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 245, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 245, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 245, 22)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 245, 51)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 245, 20)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 245, 56)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 245, 22)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 245, 62)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 245, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 245, 20)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 245, 22)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 245, 25)) +>f74 : Symbol(f74, Decl(keyofAndIndexedAccess.ts, 242, 1)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 244, 13)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 244, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 244, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 244, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 244, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 244, 22)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 244, 51)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 244, 20)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 244, 56)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 244, 22)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 244, 62)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 244, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 244, 20)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 244, 22)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 244, 25)) let a = func({ a: 1, b: "hello" }, { a: 2, b: true }, 'a'); // number ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 246, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 245, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 245, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 244, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 245, 18)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 245, 24)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 245, 40)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 245, 46)) + + let b = func({ a: 1, b: "hello" }, { a: 2, b: true }, 'b'); // string | boolean +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 246, 7)) +>func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 244, 13)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 246, 18)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 246, 24)) >a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 246, 40)) >b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 246, 46)) - - let b = func({ a: 1, b: "hello" }, { a: 2, b: true }, 'b'); // string | boolean ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 247, 7)) ->func : Symbol(func, Decl(keyofAndIndexedAccess.ts, 245, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 247, 18)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 247, 24)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 247, 40)) ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 247, 46)) } function f80(obj: T) { ->f80 : Symbol(f80, Decl(keyofAndIndexedAccess.ts, 248, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 250, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 250, 13)) +>f80 : Symbol(f80, Decl(keyofAndIndexedAccess.ts, 247, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 249, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 249, 13)) let a1 = obj.a; // { x: any } ->a1 : Symbol(a1, Decl(keyofAndIndexedAccess.ts, 251, 7)) ->obj.a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) +>a1 : Symbol(a1, Decl(keyofAndIndexedAccess.ts, 250, 7)) +>obj.a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) let a2 = obj['a']; // { x: any } ->a2 : Symbol(a2, Decl(keyofAndIndexedAccess.ts, 252, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) +>a2 : Symbol(a2, Decl(keyofAndIndexedAccess.ts, 251, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) let a3 = obj['a'] as T['a']; // T["a"] ->a3 : Symbol(a3, Decl(keyofAndIndexedAccess.ts, 253, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 250, 13)) +>a3 : Symbol(a3, Decl(keyofAndIndexedAccess.ts, 252, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 249, 13)) let x1 = obj.a.x; // any ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 254, 7)) ->obj.a.x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) ->obj.a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 253, 7)) +>obj.a.x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) +>obj.a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) let x2 = obj['a']['x']; // any ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 255, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 254, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) let x3 = obj['a']['x'] as T['a']['x']; // T["a"]["x"] ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 256, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 250, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 250, 24)) ->'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 250, 29)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 250, 13)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 255, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 249, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 249, 24)) +>'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 249, 29)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 249, 13)) } function f81(obj: T) { ->f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 257, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 259, 13)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 259, 24)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 259, 29)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 259, 42)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 259, 13)) +>f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 256, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 258, 13)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 258, 24)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 258, 29)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 258, 42)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 258, 13)) return obj['a']['x'] as T['a']['x']; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 259, 42)) ->'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 259, 24)) ->'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 259, 29)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 259, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 258, 42)) +>'a' : Symbol(a, Decl(keyofAndIndexedAccess.ts, 258, 24)) +>'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 258, 29)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 258, 13)) } function f82() { ->f82 : Symbol(f82, Decl(keyofAndIndexedAccess.ts, 261, 1)) +>f82 : Symbol(f82, Decl(keyofAndIndexedAccess.ts, 260, 1)) let x1 = f81({ a: { x: "hello" } }); // string ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 264, 7)) ->f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 257, 1)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 264, 18)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 264, 23)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 263, 7)) +>f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 256, 1)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 263, 18)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 263, 23)) let x2 = f81({ a: { x: 42 } }); // number ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 265, 7)) ->f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 257, 1)) ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 265, 18)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 265, 23)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 264, 7)) +>f81 : Symbol(f81, Decl(keyofAndIndexedAccess.ts, 256, 1)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 264, 18)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 264, 23)) } function f83(obj: T, key: K) { ->f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 266, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 268, 13)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 268, 26)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 268, 39)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 268, 51)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 268, 13)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 268, 71)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 268, 13)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 268, 78)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 268, 51)) +>f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 265, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 267, 13)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 267, 26)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 267, 39)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 267, 51)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 267, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 267, 71)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 267, 13)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 267, 78)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 267, 51)) return obj[key]['x'] as T[K]['x']; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 268, 71)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 268, 78)) ->'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 268, 39)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 268, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 268, 51)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 267, 71)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 267, 78)) +>'x' : Symbol(x, Decl(keyofAndIndexedAccess.ts, 267, 39)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 267, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 267, 51)) } function f84() { ->f84 : Symbol(f84, Decl(keyofAndIndexedAccess.ts, 270, 1)) +>f84 : Symbol(f84, Decl(keyofAndIndexedAccess.ts, 269, 1)) let x1 = f83({ foo: { x: "hello" } }, "foo"); // string ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 273, 7)) ->f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 266, 1)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 273, 18)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 273, 25)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 272, 7)) +>f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 265, 1)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 272, 18)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 272, 25)) let x2 = f83({ bar: { x: 42 } }, "bar"); // number ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 274, 7)) ->f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 266, 1)) ->bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 274, 18)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 274, 25)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 273, 7)) +>f83 : Symbol(f83, Decl(keyofAndIndexedAccess.ts, 265, 1)) +>bar : Symbol(bar, Decl(keyofAndIndexedAccess.ts, 273, 18)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 273, 25)) } class C1 { ->C1 : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) +>C1 : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) x: number; ->x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) get(key: K) { ->get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 278, 14)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 279, 8)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 279, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 279, 8)) +>get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 277, 14)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 278, 8)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 278, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 278, 8)) return this[key]; ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 279, 30)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 278, 30)) } set(key: K, value: this[K]) { ->set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 281, 5)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 282, 8)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 282, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 282, 8)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 282, 37)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 282, 8)) +>set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 280, 5)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 281, 8)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 281, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 281, 8)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 281, 37)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 281, 8)) this[key] = value; ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 282, 30)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 282, 37)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 281, 30)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 281, 37)) } foo() { ->foo : Symbol(C1.foo, Decl(keyofAndIndexedAccess.ts, 284, 5)) +>foo : Symbol(C1.foo, Decl(keyofAndIndexedAccess.ts, 283, 5)) let x1 = this.x; // number ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 286, 11)) ->this.x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 285, 11)) +>this.x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) let x2 = this["x"]; // number ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 287, 11)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->"x" : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 286, 11)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>"x" : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) let x3 = this.get("x"); // this["x"] ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 288, 11)) ->this.get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 278, 14)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 278, 14)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 287, 11)) +>this.get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 277, 14)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>get : Symbol(C1.get, Decl(keyofAndIndexedAccess.ts, 277, 14)) let x4 = getProperty(this, "x"); // this["x"] ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 289, 11)) ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 288, 11)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) this.x = 42; ->this.x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>this.x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>x : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) this["x"] = 42; ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->"x" : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 277, 10)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>"x" : Symbol(C1.x, Decl(keyofAndIndexedAccess.ts, 276, 10)) this.set("x", 42); ->this.set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 281, 5)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) ->set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 281, 5)) +>this.set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 280, 5)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) +>set : Symbol(C1.set, Decl(keyofAndIndexedAccess.ts, 280, 5)) setProperty(this, "x", 42); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 275, 1)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>this : Symbol(C1, Decl(keyofAndIndexedAccess.ts, 274, 1)) } } type S2 = { ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) a: string; ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 297, 11)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 296, 11)) b: string; ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 298, 14)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 297, 14)) }; function f90(x1: S2[keyof S2], x2: T[keyof S2], x3: S2[K], x4: T[K]) { ->f90 : Symbol(f90, Decl(keyofAndIndexedAccess.ts, 300, 2)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 302, 13)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 302, 26)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 302, 13)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) ->S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 295, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 302, 26)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 302, 13)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 302, 26)) +>f90 : Symbol(f90, Decl(keyofAndIndexedAccess.ts, 299, 2)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 301, 13)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 301, 26)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 301, 13)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) +>S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 301, 26)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 301, 13)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 301, 26)) x1 = x2; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) x1 = x3; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) x1 = x4; ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) x2 = x1; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) x2 = x3; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) x2 = x4; ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) x3 = x1; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) x3 = x2; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) x3 = x4; ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) x4 = x1; ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) x4 = x2; ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) x4 = x3; ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) x1.length; >x1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 302, 47)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 301, 47)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) x2.length; >x2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 302, 64)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 301, 64)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) x3.length; >x3.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 302, 81)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 301, 81)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) x4.length; >x4.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 302, 92)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 301, 92)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Repros from #12011 class Base { ->Base : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) +>Base : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) get(prop: K) { ->get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 323, 12)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 324, 8)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 324, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 324, 8)) +>get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 322, 12)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 323, 8)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 323, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 323, 8)) return this[prop]; ->this : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 324, 30)) +>this : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 323, 30)) } set(prop: K, value: this[K]) { ->set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 326, 5)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 327, 8)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 327, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 327, 8)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 327, 38)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 327, 8)) +>set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 325, 5)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 326, 8)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 326, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 326, 8)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 326, 38)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 326, 8)) this[prop] = value; ->this : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 327, 30)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 327, 38)) +>this : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 326, 30)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 326, 38)) } } class Person extends Base { ->Person : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 330, 1)) ->Base : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) +>Person : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 329, 1)) +>Base : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) parts: number; ->parts : Symbol(Person.parts, Decl(keyofAndIndexedAccess.ts, 332, 27)) +>parts : Symbol(Person.parts, Decl(keyofAndIndexedAccess.ts, 331, 27)) constructor(parts: number) { ->parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 334, 16)) +>parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 333, 16)) super(); ->super : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 319, 1)) +>super : Symbol(Base, Decl(keyofAndIndexedAccess.ts, 318, 1)) this.set("parts", parts); ->this.set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 326, 5)) ->this : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 330, 1)) ->set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 326, 5)) ->parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 334, 16)) +>this.set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 325, 5)) +>this : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 329, 1)) +>set : Symbol(Base.set, Decl(keyofAndIndexedAccess.ts, 325, 5)) +>parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 333, 16)) } getParts() { ->getParts : Symbol(Person.getParts, Decl(keyofAndIndexedAccess.ts, 337, 5)) +>getParts : Symbol(Person.getParts, Decl(keyofAndIndexedAccess.ts, 336, 5)) return this.get("parts") ->this.get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 323, 12)) ->this : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 330, 1)) ->get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 323, 12)) +>this.get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 322, 12)) +>this : Symbol(Person, Decl(keyofAndIndexedAccess.ts, 329, 1)) +>get : Symbol(Base.get, Decl(keyofAndIndexedAccess.ts, 322, 12)) } } class OtherPerson { ->OtherPerson : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 341, 1)) +>OtherPerson : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 340, 1)) parts: number; ->parts : Symbol(OtherPerson.parts, Decl(keyofAndIndexedAccess.ts, 343, 19)) +>parts : Symbol(OtherPerson.parts, Decl(keyofAndIndexedAccess.ts, 342, 19)) constructor(parts: number) { ->parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 345, 16)) +>parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 344, 16)) setProperty(this, "parts", parts); ->setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 81, 1)) ->this : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 341, 1)) ->parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 345, 16)) +>setProperty : Symbol(setProperty, Decl(keyofAndIndexedAccess.ts, 80, 1)) +>this : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 340, 1)) +>parts : Symbol(parts, Decl(keyofAndIndexedAccess.ts, 344, 16)) } getParts() { ->getParts : Symbol(OtherPerson.getParts, Decl(keyofAndIndexedAccess.ts, 347, 5)) +>getParts : Symbol(OtherPerson.getParts, Decl(keyofAndIndexedAccess.ts, 346, 5)) return getProperty(this, "parts") ->getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 77, 26)) ->this : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 341, 1)) +>getProperty : Symbol(getProperty, Decl(keyofAndIndexedAccess.ts, 76, 26)) +>this : Symbol(OtherPerson, Decl(keyofAndIndexedAccess.ts, 340, 1)) } } // Modified repro from #12544 function path(obj: T, key1: K1): T[K1]; ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 354, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 354, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 354, 14)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 354, 37)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 354, 14)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 354, 44)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 354, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 354, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 354, 16)) + +function path(obj: T, key1: K1, key2: K2): T[K1][K2]; +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) >K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 355, 37)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 355, 36)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 355, 61)) >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 355, 44)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 355, 68)) >K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) +>key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 355, 78)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 355, 36)) >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 355, 14)) >K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 355, 16)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 355, 36)) -function path(obj: T, key1: K1, key2: K2): T[K1][K2]; ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) +function path(obj: T, key1: K1, key2: K2, key3: K3): T[K1][K2][K3]; +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) >K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) >K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) >K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 356, 61)) +>K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 356, 60)) >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 356, 68)) >K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) ->key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 356, 78)) >K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 356, 89)) >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 356, 96)) >K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) +>key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 356, 106)) >K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) - -function path(obj: T, key1: K1, key2: K2, key3: K3): T[K1][K2][K3]; ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 357, 36)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 357, 60)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 357, 36)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 357, 89)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 357, 96)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 357, 106)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 357, 36)) ->key3 : Symbol(key3, Decl(keyofAndIndexedAccess.ts, 357, 116)) ->K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 357, 60)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 357, 14)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 357, 16)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 357, 36)) ->K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 357, 60)) +>key3 : Symbol(key3, Decl(keyofAndIndexedAccess.ts, 356, 116)) +>K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 356, 60)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 356, 14)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 356, 16)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 356, 36)) +>K3 : Symbol(K3, Decl(keyofAndIndexedAccess.ts, 356, 60)) function path(obj: any, ...keys: (string | number)[]): any; ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 358, 14)) ->keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 358, 23)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 357, 14)) +>keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 357, 23)) function path(obj: any, ...keys: (string | number)[]): any { ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 359, 14)) ->keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 359, 23)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 358, 14)) +>keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 358, 23)) let result = obj; ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 360, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 359, 14)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 359, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 358, 14)) for (let k of keys) { ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 361, 12)) ->keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 359, 23)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 360, 12)) +>keys : Symbol(keys, Decl(keyofAndIndexedAccess.ts, 358, 23)) result = result[k]; ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 360, 7)) ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 360, 7)) ->k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 361, 12)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 359, 7)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 359, 7)) +>k : Symbol(k, Decl(keyofAndIndexedAccess.ts, 360, 12)) } return result; ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 360, 7)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 359, 7)) } type Thing = { ->Thing : Symbol(Thing, Decl(keyofAndIndexedAccess.ts, 365, 1)) +>Thing : Symbol(Thing, Decl(keyofAndIndexedAccess.ts, 364, 1)) a: { x: number, y: string }, ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 367, 14)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 368, 8)) ->y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 368, 19)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 366, 14)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 367, 8)) +>y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 367, 19)) b: boolean ->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 368, 32)) +>b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 367, 32)) }; function f1(thing: Thing) { ->f1 : Symbol(f1, Decl(keyofAndIndexedAccess.ts, 370, 2)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) ->Thing : Symbol(Thing, Decl(keyofAndIndexedAccess.ts, 365, 1)) +>f1 : Symbol(f1, Decl(keyofAndIndexedAccess.ts, 369, 2)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) +>Thing : Symbol(Thing, Decl(keyofAndIndexedAccess.ts, 364, 1)) let x1 = path(thing, 'a'); // { x: number, y: string } ->x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 374, 7)) ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) +>x1 : Symbol(x1, Decl(keyofAndIndexedAccess.ts, 373, 7)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) let x2 = path(thing, 'a', 'y'); // string ->x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 375, 7)) ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) +>x2 : Symbol(x2, Decl(keyofAndIndexedAccess.ts, 374, 7)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) let x3 = path(thing, 'b'); // boolean ->x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 376, 7)) ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) +>x3 : Symbol(x3, Decl(keyofAndIndexedAccess.ts, 375, 7)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) let x4 = path(thing, ...['a', 'x']); // any ->x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 377, 7)) ->path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 351, 1), Decl(keyofAndIndexedAccess.ts, 355, 62), Decl(keyofAndIndexedAccess.ts, 356, 100), Decl(keyofAndIndexedAccess.ts, 357, 142), Decl(keyofAndIndexedAccess.ts, 358, 59)) ->thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 373, 12)) +>x4 : Symbol(x4, Decl(keyofAndIndexedAccess.ts, 376, 7)) +>path : Symbol(path, Decl(keyofAndIndexedAccess.ts, 350, 1), Decl(keyofAndIndexedAccess.ts, 354, 62), Decl(keyofAndIndexedAccess.ts, 355, 100), Decl(keyofAndIndexedAccess.ts, 356, 142), Decl(keyofAndIndexedAccess.ts, 357, 59)) +>thing : Symbol(thing, Decl(keyofAndIndexedAccess.ts, 372, 12)) } // Repro from comment in #12114 const assignTo2 = (object: T, key1: K1, key2: K2) => ->assignTo2 : Symbol(assignTo2, Decl(keyofAndIndexedAccess.ts, 382, 5)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 382, 21)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 382, 41)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 382, 21)) ->object : Symbol(object, Decl(keyofAndIndexedAccess.ts, 382, 66)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 382, 76)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 382, 21)) ->key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 382, 86)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 382, 41)) +>assignTo2 : Symbol(assignTo2, Decl(keyofAndIndexedAccess.ts, 381, 5)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 381, 21)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 381, 41)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 381, 21)) +>object : Symbol(object, Decl(keyofAndIndexedAccess.ts, 381, 66)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 381, 76)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 381, 21)) +>key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 381, 86)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 381, 41)) (value: T[K1][K2]) => object[key1][key2] = value; ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 383, 5)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 382, 19)) ->K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 382, 21)) ->K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 382, 41)) ->object : Symbol(object, Decl(keyofAndIndexedAccess.ts, 382, 66)) ->key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 382, 76)) ->key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 382, 86)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 383, 5)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 382, 5)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 381, 19)) +>K1 : Symbol(K1, Decl(keyofAndIndexedAccess.ts, 381, 21)) +>K2 : Symbol(K2, Decl(keyofAndIndexedAccess.ts, 381, 41)) +>object : Symbol(object, Decl(keyofAndIndexedAccess.ts, 381, 66)) +>key1 : Symbol(key1, Decl(keyofAndIndexedAccess.ts, 381, 76)) +>key2 : Symbol(key2, Decl(keyofAndIndexedAccess.ts, 381, 86)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 382, 5)) // Modified repro from #12573 declare function one(handler: (t: T) => void): T ->one : Symbol(one, Decl(keyofAndIndexedAccess.ts, 383, 53)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 387, 21)) ->handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 387, 24)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 387, 34)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 387, 21)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 387, 21)) +>one : Symbol(one, Decl(keyofAndIndexedAccess.ts, 382, 53)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 386, 21)) +>handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 386, 24)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 386, 34)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 386, 21)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 386, 21)) var empty = one(() => {}) // inferred as {}, expected ->empty : Symbol(empty, Decl(keyofAndIndexedAccess.ts, 388, 3)) ->one : Symbol(one, Decl(keyofAndIndexedAccess.ts, 383, 53)) +>empty : Symbol(empty, Decl(keyofAndIndexedAccess.ts, 387, 3)) +>one : Symbol(one, Decl(keyofAndIndexedAccess.ts, 382, 53)) type Handlers = { [K in keyof T]: (t: T[K]) => void } ->Handlers : Symbol(Handlers, Decl(keyofAndIndexedAccess.ts, 388, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 14)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 390, 22)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 14)) ->t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 390, 38)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 14)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 390, 22)) +>Handlers : Symbol(Handlers, Decl(keyofAndIndexedAccess.ts, 387, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 389, 14)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 389, 22)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 389, 14)) +>t : Symbol(t, Decl(keyofAndIndexedAccess.ts, 389, 38)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 389, 14)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 389, 22)) declare function on(handlerHash: Handlers): T ->on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 390, 56)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 391, 20)) ->handlerHash : Symbol(handlerHash, Decl(keyofAndIndexedAccess.ts, 391, 23)) ->Handlers : Symbol(Handlers, Decl(keyofAndIndexedAccess.ts, 388, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 391, 20)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 391, 20)) +>on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 389, 56)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 20)) +>handlerHash : Symbol(handlerHash, Decl(keyofAndIndexedAccess.ts, 390, 23)) +>Handlers : Symbol(Handlers, Decl(keyofAndIndexedAccess.ts, 387, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 20)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 390, 20)) var hashOfEmpty1 = on({ test: () => {} }); // {} ->hashOfEmpty1 : Symbol(hashOfEmpty1, Decl(keyofAndIndexedAccess.ts, 392, 3)) ->on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 390, 56)) ->test : Symbol(test, Decl(keyofAndIndexedAccess.ts, 392, 23)) +>hashOfEmpty1 : Symbol(hashOfEmpty1, Decl(keyofAndIndexedAccess.ts, 391, 3)) +>on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 389, 56)) +>test : Symbol(test, Decl(keyofAndIndexedAccess.ts, 391, 23)) var hashOfEmpty2 = on({ test: (x: boolean) => {} }); // { test: boolean } ->hashOfEmpty2 : Symbol(hashOfEmpty2, Decl(keyofAndIndexedAccess.ts, 393, 3)) ->on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 390, 56)) ->test : Symbol(test, Decl(keyofAndIndexedAccess.ts, 393, 23)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 393, 31)) +>hashOfEmpty2 : Symbol(hashOfEmpty2, Decl(keyofAndIndexedAccess.ts, 392, 3)) +>on : Symbol(on, Decl(keyofAndIndexedAccess.ts, 389, 56)) +>test : Symbol(test, Decl(keyofAndIndexedAccess.ts, 392, 23)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 392, 31)) // Repro from #12624 interface Options1 { ->Options1 : Symbol(Options1, Decl(keyofAndIndexedAccess.ts, 393, 52)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 397, 19)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 397, 24)) +>Options1 : Symbol(Options1, Decl(keyofAndIndexedAccess.ts, 392, 52)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 396, 19)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 396, 24)) data?: Data ->data : Symbol(Options1.data, Decl(keyofAndIndexedAccess.ts, 397, 36)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 397, 19)) +>data : Symbol(Options1.data, Decl(keyofAndIndexedAccess.ts, 396, 36)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 396, 19)) computed?: Computed; ->computed : Symbol(Options1.computed, Decl(keyofAndIndexedAccess.ts, 398, 15)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 397, 24)) +>computed : Symbol(Options1.computed, Decl(keyofAndIndexedAccess.ts, 397, 15)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 396, 24)) } declare class Component1 { ->Component1 : Symbol(Component1, Decl(keyofAndIndexedAccess.ts, 400, 1)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 402, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 402, 30)) +>Component1 : Symbol(Component1, Decl(keyofAndIndexedAccess.ts, 399, 1)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 401, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 401, 30)) constructor(options: Options1); ->options : Symbol(options, Decl(keyofAndIndexedAccess.ts, 403, 16)) ->Options1 : Symbol(Options1, Decl(keyofAndIndexedAccess.ts, 393, 52)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 402, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 402, 30)) +>options : Symbol(options, Decl(keyofAndIndexedAccess.ts, 402, 16)) +>Options1 : Symbol(Options1, Decl(keyofAndIndexedAccess.ts, 392, 52)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 401, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 401, 30)) get(key: K): (Data & Computed)[K]; ->get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 403, 51)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 404, 8)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 402, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 402, 30)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 404, 43)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 404, 8)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 402, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 402, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 404, 8)) +>get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 402, 51)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 403, 8)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 401, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 401, 30)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 403, 43)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 403, 8)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 401, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 401, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 403, 8)) } let c1 = new Component1({ ->c1 : Symbol(c1, Decl(keyofAndIndexedAccess.ts, 407, 3)) ->Component1 : Symbol(Component1, Decl(keyofAndIndexedAccess.ts, 400, 1)) +>c1 : Symbol(c1, Decl(keyofAndIndexedAccess.ts, 406, 3)) +>Component1 : Symbol(Component1, Decl(keyofAndIndexedAccess.ts, 399, 1)) data: { ->data : Symbol(data, Decl(keyofAndIndexedAccess.ts, 407, 25)) +>data : Symbol(data, Decl(keyofAndIndexedAccess.ts, 406, 25)) hello: "" ->hello : Symbol(hello, Decl(keyofAndIndexedAccess.ts, 408, 11)) +>hello : Symbol(hello, Decl(keyofAndIndexedAccess.ts, 407, 11)) } }); c1.get("hello"); ->c1.get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 403, 51)) ->c1 : Symbol(c1, Decl(keyofAndIndexedAccess.ts, 407, 3)) ->get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 403, 51)) +>c1.get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 402, 51)) +>c1 : Symbol(c1, Decl(keyofAndIndexedAccess.ts, 406, 3)) +>get : Symbol(Component1.get, Decl(keyofAndIndexedAccess.ts, 402, 51)) // Repro from #12625 interface Options2 { ->Options2 : Symbol(Options2, Decl(keyofAndIndexedAccess.ts, 413, 16)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 417, 19)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 417, 24)) +>Options2 : Symbol(Options2, Decl(keyofAndIndexedAccess.ts, 412, 16)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 416, 19)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 416, 24)) data?: Data ->data : Symbol(Options2.data, Decl(keyofAndIndexedAccess.ts, 417, 36)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 417, 19)) +>data : Symbol(Options2.data, Decl(keyofAndIndexedAccess.ts, 416, 36)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 416, 19)) computed?: Computed; ->computed : Symbol(Options2.computed, Decl(keyofAndIndexedAccess.ts, 418, 15)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 417, 24)) +>computed : Symbol(Options2.computed, Decl(keyofAndIndexedAccess.ts, 417, 15)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 416, 24)) } declare class Component2 { ->Component2 : Symbol(Component2, Decl(keyofAndIndexedAccess.ts, 420, 1)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 422, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 422, 30)) +>Component2 : Symbol(Component2, Decl(keyofAndIndexedAccess.ts, 419, 1)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 421, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 421, 30)) constructor(options: Options2); ->options : Symbol(options, Decl(keyofAndIndexedAccess.ts, 423, 16)) ->Options2 : Symbol(Options2, Decl(keyofAndIndexedAccess.ts, 413, 16)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 422, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 422, 30)) +>options : Symbol(options, Decl(keyofAndIndexedAccess.ts, 422, 16)) +>Options2 : Symbol(Options2, Decl(keyofAndIndexedAccess.ts, 412, 16)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 421, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 421, 30)) get(key: K): (Data & Computed)[K]; ->get : Symbol(Component2.get, Decl(keyofAndIndexedAccess.ts, 423, 51)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 424, 8)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 422, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 422, 30)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 424, 47)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 424, 8)) ->Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 422, 25)) ->Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 422, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 424, 8)) +>get : Symbol(Component2.get, Decl(keyofAndIndexedAccess.ts, 422, 51)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 423, 8)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 421, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 421, 30)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 423, 47)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 423, 8)) +>Data : Symbol(Data, Decl(keyofAndIndexedAccess.ts, 421, 25)) +>Computed : Symbol(Computed, Decl(keyofAndIndexedAccess.ts, 421, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 423, 8)) } // Repro from #12641 interface R { ->R : Symbol(R, Decl(keyofAndIndexedAccess.ts, 425, 1)) +>R : Symbol(R, Decl(keyofAndIndexedAccess.ts, 424, 1)) p: number; ->p : Symbol(R.p, Decl(keyofAndIndexedAccess.ts, 429, 13)) +>p : Symbol(R.p, Decl(keyofAndIndexedAccess.ts, 428, 13)) } function f(p: K) { ->f : Symbol(f, Decl(keyofAndIndexedAccess.ts, 431, 1)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 433, 11)) ->R : Symbol(R, Decl(keyofAndIndexedAccess.ts, 425, 1)) ->p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 433, 30)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 433, 11)) +>f : Symbol(f, Decl(keyofAndIndexedAccess.ts, 430, 1)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 432, 11)) +>R : Symbol(R, Decl(keyofAndIndexedAccess.ts, 424, 1)) +>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 432, 30)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 432, 11)) let a: any; ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 434, 7)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 433, 7)) a[p].add; // any ->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 434, 7)) ->p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 433, 30)) +>a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 433, 7)) +>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 432, 30)) } // Repro from #12651 type MethodDescriptor = { ->MethodDescriptor : Symbol(MethodDescriptor, Decl(keyofAndIndexedAccess.ts, 436, 1)) +>MethodDescriptor : Symbol(MethodDescriptor, Decl(keyofAndIndexedAccess.ts, 435, 1)) name: string; ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 440, 25)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 439, 25)) args: any[]; ->args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 441, 14)) +>args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 440, 14)) returnValue: any; ->returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 442, 13)) +>returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 441, 13)) } declare function dispatchMethod(name: M['name'], args: M['args']): M['returnValue']; ->dispatchMethod : Symbol(dispatchMethod, Decl(keyofAndIndexedAccess.ts, 444, 1)) ->M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 446, 32)) ->MethodDescriptor : Symbol(MethodDescriptor, Decl(keyofAndIndexedAccess.ts, 436, 1)) ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 446, 60)) ->M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 446, 32)) ->args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 446, 76)) ->M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 446, 32)) ->M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 446, 32)) +>dispatchMethod : Symbol(dispatchMethod, Decl(keyofAndIndexedAccess.ts, 443, 1)) +>M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 445, 32)) +>MethodDescriptor : Symbol(MethodDescriptor, Decl(keyofAndIndexedAccess.ts, 435, 1)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 445, 60)) +>M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 445, 32)) +>args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 445, 76)) +>M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 445, 32)) +>M : Symbol(M, Decl(keyofAndIndexedAccess.ts, 445, 32)) type SomeMethodDescriptor = { ->SomeMethodDescriptor : Symbol(SomeMethodDescriptor, Decl(keyofAndIndexedAccess.ts, 446, 112)) +>SomeMethodDescriptor : Symbol(SomeMethodDescriptor, Decl(keyofAndIndexedAccess.ts, 445, 112)) name: "someMethod"; ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 448, 29)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 447, 29)) args: [string, number]; ->args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 449, 20)) +>args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 448, 20)) returnValue: string[]; ->returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 450, 24)) +>returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 449, 24)) } let result = dispatchMethod("someMethod", ["hello", 35]); ->result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 454, 3)) ->dispatchMethod : Symbol(dispatchMethod, Decl(keyofAndIndexedAccess.ts, 444, 1)) ->SomeMethodDescriptor : Symbol(SomeMethodDescriptor, Decl(keyofAndIndexedAccess.ts, 446, 112)) +>result : Symbol(result, Decl(keyofAndIndexedAccess.ts, 453, 3)) +>dispatchMethod : Symbol(dispatchMethod, Decl(keyofAndIndexedAccess.ts, 443, 1)) +>SomeMethodDescriptor : Symbol(SomeMethodDescriptor, Decl(keyofAndIndexedAccess.ts, 445, 112)) // Repro from #13073 type KeyTypes = "a" | "b" ->KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 454, 79)) +>KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 453, 79)) let MyThingy: { [key in KeyTypes]: string[] }; ->MyThingy : Symbol(MyThingy, Decl(keyofAndIndexedAccess.ts, 459, 3)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 459, 17)) ->KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 454, 79)) +>MyThingy : Symbol(MyThingy, Decl(keyofAndIndexedAccess.ts, 458, 3)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 458, 17)) +>KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 453, 79)) function addToMyThingy(key: S) { ->addToMyThingy : Symbol(addToMyThingy, Decl(keyofAndIndexedAccess.ts, 459, 46)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 461, 23)) ->KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 454, 79)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 461, 43)) ->S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 461, 23)) +>addToMyThingy : Symbol(addToMyThingy, Decl(keyofAndIndexedAccess.ts, 458, 46)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 460, 23)) +>KeyTypes : Symbol(KeyTypes, Decl(keyofAndIndexedAccess.ts, 453, 79)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 460, 43)) +>S : Symbol(S, Decl(keyofAndIndexedAccess.ts, 460, 23)) MyThingy[key].push("a"); >MyThingy[key].push : Symbol(Array.push, Decl(lib.d.ts, --, --)) ->MyThingy : Symbol(MyThingy, Decl(keyofAndIndexedAccess.ts, 459, 3)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 461, 43)) +>MyThingy : Symbol(MyThingy, Decl(keyofAndIndexedAccess.ts, 458, 3)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 460, 43)) >push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } // Repro from #13102 type Handler = { ->Handler : Symbol(Handler, Decl(keyofAndIndexedAccess.ts, 463, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 467, 13)) +>Handler : Symbol(Handler, Decl(keyofAndIndexedAccess.ts, 462, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 466, 13)) onChange: (name: keyof T) => void; ->onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 467, 19)) ->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 468, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 467, 13)) +>onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 466, 19)) +>name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 467, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 466, 13)) }; function onChangeGenericFunction(handler: Handler) { ->onChangeGenericFunction : Symbol(onChangeGenericFunction, Decl(keyofAndIndexedAccess.ts, 469, 2)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 471, 33)) ->handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 471, 36)) ->Handler : Symbol(Handler, Decl(keyofAndIndexedAccess.ts, 463, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 471, 33)) ->preset : Symbol(preset, Decl(keyofAndIndexedAccess.ts, 471, 58)) +>onChangeGenericFunction : Symbol(onChangeGenericFunction, Decl(keyofAndIndexedAccess.ts, 468, 2)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 470, 33)) +>handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 470, 36)) +>Handler : Symbol(Handler, Decl(keyofAndIndexedAccess.ts, 462, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 470, 33)) +>preset : Symbol(preset, Decl(keyofAndIndexedAccess.ts, 470, 58)) handler.onChange('preset') ->handler.onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 467, 19)) ->handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 471, 36)) ->onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 467, 19)) +>handler.onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 466, 19)) +>handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 470, 36)) +>onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 466, 19)) } // Repro from #13285 function updateIds, K extends string>( ->updateIds : Symbol(updateIds, Decl(keyofAndIndexedAccess.ts, 473, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 477, 19)) +>updateIds : Symbol(updateIds, Decl(keyofAndIndexedAccess.ts, 472, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 476, 19)) >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 477, 47)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 477, 47)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 476, 47)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 476, 47)) obj: T, ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 477, 66)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 477, 19)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 476, 66)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 476, 19)) idFields: K[], ->idFields : Symbol(idFields, Decl(keyofAndIndexedAccess.ts, 478, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 477, 47)) +>idFields : Symbol(idFields, Decl(keyofAndIndexedAccess.ts, 477, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 476, 47)) idMapping: { [oldId: string]: string } ->idMapping : Symbol(idMapping, Decl(keyofAndIndexedAccess.ts, 479, 18)) ->oldId : Symbol(oldId, Decl(keyofAndIndexedAccess.ts, 480, 18)) +>idMapping : Symbol(idMapping, Decl(keyofAndIndexedAccess.ts, 478, 18)) +>oldId : Symbol(oldId, Decl(keyofAndIndexedAccess.ts, 479, 18)) ): Record { >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 477, 47)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 476, 47)) for (const idField of idFields) { ->idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 482, 14)) ->idFields : Symbol(idFields, Decl(keyofAndIndexedAccess.ts, 478, 11)) +>idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 481, 14)) +>idFields : Symbol(idFields, Decl(keyofAndIndexedAccess.ts, 477, 11)) const newId = idMapping[obj[idField]]; ->newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 483, 13)) ->idMapping : Symbol(idMapping, Decl(keyofAndIndexedAccess.ts, 479, 18)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 477, 66)) ->idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 482, 14)) +>newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 482, 13)) +>idMapping : Symbol(idMapping, Decl(keyofAndIndexedAccess.ts, 478, 18)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 476, 66)) +>idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 481, 14)) if (newId) { ->newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 483, 13)) +>newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 482, 13)) obj[idField] = newId; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 477, 66)) ->idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 482, 14)) ->newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 483, 13)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 476, 66)) +>idField : Symbol(idField, Decl(keyofAndIndexedAccess.ts, 481, 14)) +>newId : Symbol(newId, Decl(keyofAndIndexedAccess.ts, 482, 13)) } } return obj; ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 477, 66)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 476, 66)) } // Repro from #13285 function updateIds2( ->updateIds2 : Symbol(updateIds2, Decl(keyofAndIndexedAccess.ts, 489, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 493, 20)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 493, 33)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 493, 54)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 493, 20)) +>updateIds2 : Symbol(updateIds2, Decl(keyofAndIndexedAccess.ts, 488, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 492, 20)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 492, 33)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 492, 54)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 492, 20)) obj: T, ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 493, 74)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 493, 20)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 492, 74)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 492, 20)) key: K, ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 494, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 493, 54)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 493, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 492, 54)) stringMap: { [oldId: string]: string } ->stringMap : Symbol(stringMap, Decl(keyofAndIndexedAccess.ts, 495, 11)) ->oldId : Symbol(oldId, Decl(keyofAndIndexedAccess.ts, 496, 18)) +>stringMap : Symbol(stringMap, Decl(keyofAndIndexedAccess.ts, 494, 11)) +>oldId : Symbol(oldId, Decl(keyofAndIndexedAccess.ts, 495, 18)) ) { var x = obj[key]; ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 498, 7)) ->obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 493, 74)) ->key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 494, 11)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 497, 7)) +>obj : Symbol(obj, Decl(keyofAndIndexedAccess.ts, 492, 74)) +>key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 493, 11)) stringMap[x]; // Should be OK. ->stringMap : Symbol(stringMap, Decl(keyofAndIndexedAccess.ts, 495, 11)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 498, 7)) +>stringMap : Symbol(stringMap, Decl(keyofAndIndexedAccess.ts, 494, 11)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 497, 7)) } // Repro from #13514 declare function head>(list: T): T[0]; ->head : Symbol(head, Decl(keyofAndIndexedAccess.ts, 500, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22)) +>head : Symbol(head, Decl(keyofAndIndexedAccess.ts, 499, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 503, 22)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->list : Symbol(list, Decl(keyofAndIndexedAccess.ts, 504, 44)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22)) +>list : Symbol(list, Decl(keyofAndIndexedAccess.ts, 503, 44)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 503, 22)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 503, 22)) // Repro from #13604 class A { ->A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 504, 59)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 508, 8)) +>A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 503, 59)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 507, 8)) props: T & { foo: string }; ->props : Symbol(A.props, Decl(keyofAndIndexedAccess.ts, 508, 12)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 508, 8)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 509, 13)) +>props : Symbol(A.props, Decl(keyofAndIndexedAccess.ts, 507, 12)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 507, 8)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 508, 13)) } class B extends A<{ x: number}> { ->B : Symbol(B, Decl(keyofAndIndexedAccess.ts, 510, 1)) ->A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 504, 59)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 512, 19)) +>B : Symbol(B, Decl(keyofAndIndexedAccess.ts, 509, 1)) +>A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 503, 59)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 511, 19)) f(p: this["props"]) { ->f : Symbol(B.f, Decl(keyofAndIndexedAccess.ts, 512, 33)) ->p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 513, 3)) +>f : Symbol(B.f, Decl(keyofAndIndexedAccess.ts, 511, 33)) +>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 512, 3)) p.x; ->p.x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 512, 19)) ->p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 513, 3)) ->x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 512, 19)) +>p.x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 511, 19)) +>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 512, 3)) +>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 511, 19)) } } // Repro from #13749 class Form { ->Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 516, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) +>Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 515, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) private childFormFactories: {[K in keyof T]: (v: T[K]) => Form} ->childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 520, 15)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 521, 34)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->v : Symbol(v, Decl(keyofAndIndexedAccess.ts, 521, 50)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 521, 34)) ->Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 516, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 521, 34)) +>childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 519, 15)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 520, 34)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>v : Symbol(v, Decl(keyofAndIndexedAccess.ts, 520, 50)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 520, 34)) +>Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 515, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 520, 34)) public set(prop: K, value: T[K]) { ->set : Symbol(Form.set, Decl(keyofAndIndexedAccess.ts, 521, 73)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 523, 15)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 523, 34)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 523, 15)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 523, 42)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11)) ->K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 523, 15)) +>set : Symbol(Form.set, Decl(keyofAndIndexedAccess.ts, 520, 73)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 522, 15)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 522, 34)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 522, 15)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 522, 42)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 519, 11)) +>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 522, 15)) this.childFormFactories[prop](value) ->this.childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 520, 15)) ->this : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 516, 1)) ->childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 520, 15)) ->prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 523, 34)) ->value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 523, 42)) +>this.childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 519, 15)) +>this : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 515, 1)) +>childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 519, 15)) +>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 522, 34)) +>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 522, 42)) } } // Repro from #13787 class SampleClass

{ ->SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1)) ->P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 530, 18)) +>SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 525, 1)) +>P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 529, 18)) public props: Readonly

; ->props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) +>props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 530, 18)) +>P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 529, 18)) constructor(props: P) { ->props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 532, 16)) ->P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 530, 18)) +>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 531, 16)) +>P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 529, 18)) this.props = Object.freeze(props); ->this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) ->this : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1)) ->props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) +>this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) +>this : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 525, 1)) +>props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) >Object.freeze : Symbol(ObjectConstructor.freeze, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >freeze : Symbol(ObjectConstructor.freeze, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 532, 16)) +>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 531, 16)) } } interface Foo { ->Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 535, 1)) +>Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 534, 1)) foo: string; ->foo : Symbol(Foo.foo, Decl(keyofAndIndexedAccess.ts, 537, 15)) +>foo : Symbol(Foo.foo, Decl(keyofAndIndexedAccess.ts, 536, 15)) } declare function merge(obj1: T, obj2: U): T & U; ->merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 539, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 541, 23)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 541, 25)) ->obj1 : Symbol(obj1, Decl(keyofAndIndexedAccess.ts, 541, 29)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 541, 23)) ->obj2 : Symbol(obj2, Decl(keyofAndIndexedAccess.ts, 541, 37)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 541, 25)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 541, 23)) ->U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 541, 25)) +>merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 538, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 540, 23)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 540, 25)) +>obj1 : Symbol(obj1, Decl(keyofAndIndexedAccess.ts, 540, 29)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 540, 23)) +>obj2 : Symbol(obj2, Decl(keyofAndIndexedAccess.ts, 540, 37)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 540, 25)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 540, 23)) +>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 540, 25)) class AnotherSampleClass extends SampleClass { ->AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 541, 54)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 543, 25)) ->SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 543, 25)) ->Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 535, 1)) +>AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 540, 54)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 542, 25)) +>SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 525, 1)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 542, 25)) +>Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 534, 1)) constructor(props: T) { ->props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 544, 16)) ->T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 543, 25)) +>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 543, 16)) +>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 542, 25)) const foo: Foo = { foo: "bar" }; ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 545, 13)) ->Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 535, 1)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 545, 26)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 544, 13)) +>Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 534, 1)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 544, 26)) super(merge(props, foo)); ->super : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1)) ->merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 539, 1)) ->props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 544, 16)) ->foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 545, 13)) +>super : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 525, 1)) +>merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 538, 1)) +>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 543, 16)) +>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 544, 13)) } public brokenMethod() { ->brokenMethod : Symbol(AnotherSampleClass.brokenMethod, Decl(keyofAndIndexedAccess.ts, 547, 5)) +>brokenMethod : Symbol(AnotherSampleClass.brokenMethod, Decl(keyofAndIndexedAccess.ts, 546, 5)) this.props.foo.concat; >this.props.foo.concat : Symbol(String.concat, Decl(lib.d.ts, --, --)) >this.props.foo : Symbol(foo) ->this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) ->this : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 541, 54)) ->props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22)) +>this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) +>this : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 540, 54)) +>props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 529, 22)) >foo : Symbol(foo) >concat : Symbol(String.concat, Decl(lib.d.ts, --, --)) } } new AnotherSampleClass({}); ->AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 541, 54)) +>AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 540, 54)) diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types index 66605b41b75b6..19ecac10188ac 100644 --- a/tests/baselines/reference/keyofAndIndexedAccess.types +++ b/tests/baselines/reference/keyofAndIndexedAccess.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts === - class Shape { >Shape : Shape @@ -1867,9 +1866,9 @@ let c1 = new Component1({ c1.get("hello"); >c1.get("hello") : string ->c1.get : (key: K) => ({ hello: string; } & {})[K] +>c1.get : (key: K) => { hello: string; }[K] >c1 : Component1<{ hello: string; }, {}> ->get : (key: K) => ({ hello: string; } & {})[K] +>get : (key: K) => { hello: string; }[K] >"hello" : "hello" // Repro from #12625 diff --git a/tests/baselines/reference/keywordInJsxIdentifier.js b/tests/baselines/reference/keywordInJsxIdentifier.js index d9c3b51e9a30b..f88fe4dff877b 100644 --- a/tests/baselines/reference/keywordInJsxIdentifier.js +++ b/tests/baselines/reference/keywordInJsxIdentifier.js @@ -1,5 +1,4 @@ //// [keywordInJsxIdentifier.tsx] - declare var React: any; ; ; diff --git a/tests/baselines/reference/keywordInJsxIdentifier.symbols b/tests/baselines/reference/keywordInJsxIdentifier.symbols index 73ee737616440..b56f0af3285be 100644 --- a/tests/baselines/reference/keywordInJsxIdentifier.symbols +++ b/tests/baselines/reference/keywordInJsxIdentifier.symbols @@ -1,21 +1,20 @@ === tests/cases/compiler/keywordInJsxIdentifier.tsx === - declare var React: any; ->React : Symbol(React, Decl(keywordInJsxIdentifier.tsx, 1, 11)) +>React : Symbol(React, Decl(keywordInJsxIdentifier.tsx, 0, 11)) ; >foo : Symbol(unknown) ->class-id : Symbol(class-id, Decl(keywordInJsxIdentifier.tsx, 2, 4)) +>class-id : Symbol(class-id, Decl(keywordInJsxIdentifier.tsx, 1, 4)) ; >foo : Symbol(unknown) ->class : Symbol(class, Decl(keywordInJsxIdentifier.tsx, 3, 4)) +>class : Symbol(class, Decl(keywordInJsxIdentifier.tsx, 2, 4)) ; >foo : Symbol(unknown) ->class-id : Symbol(class-id, Decl(keywordInJsxIdentifier.tsx, 4, 4)) +>class-id : Symbol(class-id, Decl(keywordInJsxIdentifier.tsx, 3, 4)) ; >foo : Symbol(unknown) ->class : Symbol(class, Decl(keywordInJsxIdentifier.tsx, 5, 4)) +>class : Symbol(class, Decl(keywordInJsxIdentifier.tsx, 4, 4)) diff --git a/tests/baselines/reference/keywordInJsxIdentifier.types b/tests/baselines/reference/keywordInJsxIdentifier.types index 0e4c4387cf47e..09ae09340de5e 100644 --- a/tests/baselines/reference/keywordInJsxIdentifier.types +++ b/tests/baselines/reference/keywordInJsxIdentifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/keywordInJsxIdentifier.tsx === - declare var React: any; >React : any diff --git a/tests/baselines/reference/lambdaASIEmit.js b/tests/baselines/reference/lambdaASIEmit.js index 49672b75c7cde..b60c772cf1ebe 100644 --- a/tests/baselines/reference/lambdaASIEmit.js +++ b/tests/baselines/reference/lambdaASIEmit.js @@ -1,5 +1,4 @@ //// [lambdaASIEmit.ts] - function Foo(x: any) { } diff --git a/tests/baselines/reference/lambdaASIEmit.symbols b/tests/baselines/reference/lambdaASIEmit.symbols index d33cc16817a3c..d57bbf60a7f00 100644 --- a/tests/baselines/reference/lambdaASIEmit.symbols +++ b/tests/baselines/reference/lambdaASIEmit.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/lambdaASIEmit.ts === - function Foo(x: any) >Foo : Symbol(Foo, Decl(lambdaASIEmit.ts, 0, 0)) ->x : Symbol(x, Decl(lambdaASIEmit.ts, 1, 13)) +>x : Symbol(x, Decl(lambdaASIEmit.ts, 0, 13)) { } diff --git a/tests/baselines/reference/lambdaASIEmit.types b/tests/baselines/reference/lambdaASIEmit.types index 381e45c5fd2a0..2f9db646ebbd8 100644 --- a/tests/baselines/reference/lambdaASIEmit.types +++ b/tests/baselines/reference/lambdaASIEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/lambdaASIEmit.ts === - function Foo(x: any) >Foo : (x: any) => void >x : any diff --git a/tests/baselines/reference/letAndVarRedeclaration.errors.txt b/tests/baselines/reference/letAndVarRedeclaration.errors.txt index 50a916e8d9003..19f0b8faf8ed2 100644 --- a/tests/baselines/reference/letAndVarRedeclaration.errors.txt +++ b/tests/baselines/reference/letAndVarRedeclaration.errors.txt @@ -1,29 +1,27 @@ -tests/cases/compiler/letAndVarRedeclaration.ts(3,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. -tests/cases/compiler/letAndVarRedeclaration.ts(4,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. -tests/cases/compiler/letAndVarRedeclaration.ts(5,10): error TS2451: Cannot redeclare block-scoped variable 'e0'. -tests/cases/compiler/letAndVarRedeclaration.ts(8,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. -tests/cases/compiler/letAndVarRedeclaration.ts(9,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. -tests/cases/compiler/letAndVarRedeclaration.ts(10,14): error TS2451: Cannot redeclare block-scoped variable 'x1'. -tests/cases/compiler/letAndVarRedeclaration.ts(14,9): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/letAndVarRedeclaration.ts(16,13): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/letAndVarRedeclaration.ts(19,18): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/letAndVarRedeclaration.ts(24,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(25,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(26,14): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(30,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(32,13): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(35,18): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(39,5): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(40,10): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(44,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(45,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(50,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(51,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. +tests/cases/compiler/letAndVarRedeclaration.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. +tests/cases/compiler/letAndVarRedeclaration.ts(3,10): error TS2451: Cannot redeclare block-scoped variable 'e0'. +tests/cases/compiler/letAndVarRedeclaration.ts(6,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. +tests/cases/compiler/letAndVarRedeclaration.ts(7,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. +tests/cases/compiler/letAndVarRedeclaration.ts(8,14): error TS2451: Cannot redeclare block-scoped variable 'x1'. +tests/cases/compiler/letAndVarRedeclaration.ts(12,9): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/letAndVarRedeclaration.ts(14,13): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/letAndVarRedeclaration.ts(17,18): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/letAndVarRedeclaration.ts(22,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(23,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(24,14): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(28,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(30,13): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(33,18): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(37,5): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(38,10): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(42,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(43,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(48,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(49,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. ==== tests/cases/compiler/letAndVarRedeclaration.ts (21 errors) ==== - - let e0 ~~ !!! error TS2451: Cannot redeclare block-scoped variable 'e0'. diff --git a/tests/baselines/reference/letAndVarRedeclaration.js b/tests/baselines/reference/letAndVarRedeclaration.js index eb4dfc9c0e831..a87828f11ff3c 100644 --- a/tests/baselines/reference/letAndVarRedeclaration.js +++ b/tests/baselines/reference/letAndVarRedeclaration.js @@ -1,6 +1,4 @@ //// [letAndVarRedeclaration.ts] - - let e0 var e0; function e0() { } diff --git a/tests/baselines/reference/letAsIdentifier.errors.txt b/tests/baselines/reference/letAsIdentifier.errors.txt index b4e4db2285344..e9b42267dcf8d 100644 --- a/tests/baselines/reference/letAsIdentifier.errors.txt +++ b/tests/baselines/reference/letAsIdentifier.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letAsIdentifier.ts(3,5): error TS2300: Duplicate identifier 'a'. -tests/cases/compiler/letAsIdentifier.ts(6,1): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/letAsIdentifier.ts(2,5): error TS2300: Duplicate identifier 'a'. +tests/cases/compiler/letAsIdentifier.ts(5,1): error TS2300: Duplicate identifier 'a'. ==== tests/cases/compiler/letAsIdentifier.ts (2 errors) ==== - var let = 10; var a = 10; ~ diff --git a/tests/baselines/reference/letAsIdentifier.js b/tests/baselines/reference/letAsIdentifier.js index 05811ce108890..98c68154227ce 100644 --- a/tests/baselines/reference/letAsIdentifier.js +++ b/tests/baselines/reference/letAsIdentifier.js @@ -1,5 +1,4 @@ //// [letAsIdentifier.ts] - var let = 10; var a = 10; let = 30; diff --git a/tests/baselines/reference/letAsIdentifier2.js b/tests/baselines/reference/letAsIdentifier2.js index 62c8461bfc818..ef1568b40cd73 100644 --- a/tests/baselines/reference/letAsIdentifier2.js +++ b/tests/baselines/reference/letAsIdentifier2.js @@ -1,5 +1,4 @@ //// [letAsIdentifier2.ts] - function let() {} //// [letAsIdentifier2.js] diff --git a/tests/baselines/reference/letAsIdentifier2.symbols b/tests/baselines/reference/letAsIdentifier2.symbols index 211aae053161a..bd0faaf6801c8 100644 --- a/tests/baselines/reference/letAsIdentifier2.symbols +++ b/tests/baselines/reference/letAsIdentifier2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/letAsIdentifier2.ts === - function let() {} >let : Symbol(let, Decl(letAsIdentifier2.ts, 0, 0)) diff --git a/tests/baselines/reference/letAsIdentifier2.types b/tests/baselines/reference/letAsIdentifier2.types index dc1416fdae903..07ce071011e01 100644 --- a/tests/baselines/reference/letAsIdentifier2.types +++ b/tests/baselines/reference/letAsIdentifier2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letAsIdentifier2.ts === - function let() {} >let : () => void diff --git a/tests/baselines/reference/letConstInCaseClauses.errors.txt b/tests/baselines/reference/letConstInCaseClauses.errors.txt index 754da95d367c8..ae56fe47a799a 100644 --- a/tests/baselines/reference/letConstInCaseClauses.errors.txt +++ b/tests/baselines/reference/letConstInCaseClauses.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/letConstInCaseClauses.ts(7,5): error TS2304: Cannot find name 'console'. -tests/cases/compiler/letConstInCaseClauses.ts(21,5): error TS2304: Cannot find name 'console'. -tests/cases/compiler/letConstInCaseClauses.ts(23,14): error TS2678: Type '10' is not comparable to type '1'. -tests/cases/compiler/letConstInCaseClauses.ts(27,14): error TS2678: Type '10' is not comparable to type '2'. +tests/cases/compiler/letConstInCaseClauses.ts(6,5): error TS2304: Cannot find name 'console'. +tests/cases/compiler/letConstInCaseClauses.ts(20,5): error TS2304: Cannot find name 'console'. +tests/cases/compiler/letConstInCaseClauses.ts(22,14): error TS2678: Type '10' is not comparable to type '1'. +tests/cases/compiler/letConstInCaseClauses.ts(26,14): error TS2678: Type '10' is not comparable to type '2'. ==== tests/cases/compiler/letConstInCaseClauses.ts (4 errors) ==== - var x = 10; var y = 20; { diff --git a/tests/baselines/reference/letConstInCaseClauses.js b/tests/baselines/reference/letConstInCaseClauses.js index 33650dcaf4caf..0252537cd3e94 100644 --- a/tests/baselines/reference/letConstInCaseClauses.js +++ b/tests/baselines/reference/letConstInCaseClauses.js @@ -1,5 +1,4 @@ //// [letConstInCaseClauses.ts] - var x = 10; var y = 20; { diff --git a/tests/baselines/reference/letDeclarations-access.js b/tests/baselines/reference/letDeclarations-access.js index 6ae289d220f91..bc792089de063 100644 --- a/tests/baselines/reference/letDeclarations-access.js +++ b/tests/baselines/reference/letDeclarations-access.js @@ -1,5 +1,4 @@ //// [letDeclarations-access.ts] - let x = 0 // No errors diff --git a/tests/baselines/reference/letDeclarations-access.symbols b/tests/baselines/reference/letDeclarations-access.symbols index 078ad740d20f4..31a64fab3f811 100644 --- a/tests/baselines/reference/letDeclarations-access.symbols +++ b/tests/baselines/reference/letDeclarations-access.symbols @@ -1,87 +1,86 @@ === tests/cases/compiler/letDeclarations-access.ts === - let x = 0 ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) // No errors x = 1; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x += 2; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x -= 3; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x *= 4; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x /= 5; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x %= 6; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x <<= 7; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x >>= 8; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x >>>= 9; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x &= 10; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x |= 11; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x ^= 12; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x++; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x--; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) ++x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) --x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) var a = x + 1; ->a : Symbol(a, Decl(letDeclarations-access.ts, 23, 3)) ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>a : Symbol(a, Decl(letDeclarations-access.ts, 22, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) function f(v: number) { } ->f : Symbol(f, Decl(letDeclarations-access.ts, 23, 14)) ->v : Symbol(v, Decl(letDeclarations-access.ts, 25, 11)) +>f : Symbol(f, Decl(letDeclarations-access.ts, 22, 14)) +>v : Symbol(v, Decl(letDeclarations-access.ts, 24, 11)) f(x); ->f : Symbol(f, Decl(letDeclarations-access.ts, 23, 14)) ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>f : Symbol(f, Decl(letDeclarations-access.ts, 22, 14)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) if (x) { } ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) (x); ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) -x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) +x; ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) x.toString(); >x.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) ->x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) +>x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3)) >toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) diff --git a/tests/baselines/reference/letDeclarations-access.types b/tests/baselines/reference/letDeclarations-access.types index b2f984a4956f8..e36d7b7ad0244 100644 --- a/tests/baselines/reference/letDeclarations-access.types +++ b/tests/baselines/reference/letDeclarations-access.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letDeclarations-access.ts === - let x = 0 >x : number >0 : 0 diff --git a/tests/baselines/reference/letDeclarations-es5.js b/tests/baselines/reference/letDeclarations-es5.js index d8761ccbc6451..a6df75c05eea9 100644 --- a/tests/baselines/reference/letDeclarations-es5.js +++ b/tests/baselines/reference/letDeclarations-es5.js @@ -1,5 +1,4 @@ //// [letDeclarations-es5.ts] - let l1; let l2: number; let l3, l4, l5 :string, l6; diff --git a/tests/baselines/reference/letDeclarations-es5.symbols b/tests/baselines/reference/letDeclarations-es5.symbols index ac2daaaac8933..512f384dc9506 100644 --- a/tests/baselines/reference/letDeclarations-es5.symbols +++ b/tests/baselines/reference/letDeclarations-es5.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/letDeclarations-es5.ts === - let l1; ->l1 : Symbol(l1, Decl(letDeclarations-es5.ts, 1, 3)) +>l1 : Symbol(l1, Decl(letDeclarations-es5.ts, 0, 3)) let l2: number; ->l2 : Symbol(l2, Decl(letDeclarations-es5.ts, 2, 3)) +>l2 : Symbol(l2, Decl(letDeclarations-es5.ts, 1, 3)) let l3, l4, l5 :string, l6; ->l3 : Symbol(l3, Decl(letDeclarations-es5.ts, 3, 3)) ->l4 : Symbol(l4, Decl(letDeclarations-es5.ts, 3, 7)) ->l5 : Symbol(l5, Decl(letDeclarations-es5.ts, 3, 11)) ->l6 : Symbol(l6, Decl(letDeclarations-es5.ts, 3, 23)) +>l3 : Symbol(l3, Decl(letDeclarations-es5.ts, 2, 3)) +>l4 : Symbol(l4, Decl(letDeclarations-es5.ts, 2, 7)) +>l5 : Symbol(l5, Decl(letDeclarations-es5.ts, 2, 11)) +>l6 : Symbol(l6, Decl(letDeclarations-es5.ts, 2, 23)) let l7 = false; ->l7 : Symbol(l7, Decl(letDeclarations-es5.ts, 5, 3)) +>l7 : Symbol(l7, Decl(letDeclarations-es5.ts, 4, 3)) let l8: number = 23; ->l8 : Symbol(l8, Decl(letDeclarations-es5.ts, 6, 3)) +>l8 : Symbol(l8, Decl(letDeclarations-es5.ts, 5, 3)) let l9 = 0, l10 :string = "", l11 = null; ->l9 : Symbol(l9, Decl(letDeclarations-es5.ts, 7, 3)) ->l10 : Symbol(l10, Decl(letDeclarations-es5.ts, 7, 11)) ->l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 7, 29)) +>l9 : Symbol(l9, Decl(letDeclarations-es5.ts, 6, 3)) +>l10 : Symbol(l10, Decl(letDeclarations-es5.ts, 6, 11)) +>l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 6, 29)) for(let l11 in {}) { } ->l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 9, 7)) +>l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 8, 7)) for(let l12 = 0; l12 < 9; l12++) { } ->l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 11, 7)) ->l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 11, 7)) ->l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 11, 7)) +>l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 10, 7)) +>l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 10, 7)) +>l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 10, 7)) diff --git a/tests/baselines/reference/letDeclarations-es5.types b/tests/baselines/reference/letDeclarations-es5.types index 9756951e705b1..5d0f69576a9df 100644 --- a/tests/baselines/reference/letDeclarations-es5.types +++ b/tests/baselines/reference/letDeclarations-es5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letDeclarations-es5.ts === - let l1; >l1 : any diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt index d8230f2970398..2541dd107c568 100644 --- a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt +++ b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt @@ -1,17 +1,15 @@ +tests/cases/compiler/letDeclarations-invalidContexts.ts(3,5): error TS1157: 'let' declarations can only be declared inside a block. tests/cases/compiler/letDeclarations-invalidContexts.ts(5,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(7,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(10,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(13,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(17,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. -tests/cases/compiler/letDeclarations-invalidContexts.ts(21,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(24,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(27,12): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(30,29): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(8,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(11,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(15,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/letDeclarations-invalidContexts.ts(19,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(22,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(25,12): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(28,29): error TS1157: 'let' declarations can only be declared inside a block. ==== tests/cases/compiler/letDeclarations-invalidContexts.ts (9 errors) ==== - - // Errors, let must be defined inside a block if (true) let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.js b/tests/baselines/reference/letDeclarations-invalidContexts.js index 4c3be1faed80c..ab06efa05fae4 100644 --- a/tests/baselines/reference/letDeclarations-invalidContexts.js +++ b/tests/baselines/reference/letDeclarations-invalidContexts.js @@ -1,6 +1,4 @@ //// [letDeclarations-invalidContexts.ts] - - // Errors, let must be defined inside a block if (true) let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates.errors.txt index b3b620a4c9ee8..ced56226e2ef8 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates.errors.txt @@ -1,31 +1,30 @@ +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(3,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(4,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(6,5): error TS2451: Cannot redeclare block-scoped variable 'var2'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(7,7): error TS2451: Cannot redeclare block-scoped variable 'var2'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(9,7): error TS2451: Cannot redeclare block-scoped variable 'var3'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(10,5): error TS2451: Cannot redeclare block-scoped variable 'var3'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(5,5): error TS2451: Cannot redeclare block-scoped variable 'var2'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(6,7): error TS2451: Cannot redeclare block-scoped variable 'var2'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(8,7): error TS2451: Cannot redeclare block-scoped variable 'var3'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(9,5): error TS2451: Cannot redeclare block-scoped variable 'var3'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(11,7): error TS2451: Cannot redeclare block-scoped variable 'var4'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(12,7): error TS2451: Cannot redeclare block-scoped variable 'var4'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(13,7): error TS2451: Cannot redeclare block-scoped variable 'var4'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(14,5): error TS2300: Duplicate identifier 'var5'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(15,5): error TS2300: Duplicate identifier 'var5'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(16,5): error TS2300: Duplicate identifier 'var5'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(17,5): error TS2451: Cannot redeclare block-scoped variable 'var6'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(18,5): error TS2451: Cannot redeclare block-scoped variable 'var6'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(19,5): error TS2451: Cannot redeclare block-scoped variable 'var6'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(21,9): error TS2451: Cannot redeclare block-scoped variable 'var7'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(22,9): error TS2451: Cannot redeclare block-scoped variable 'var7'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(23,9): error TS2451: Cannot redeclare block-scoped variable 'var7'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(25,13): error TS2451: Cannot redeclare block-scoped variable 'var8'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(26,15): error TS2451: Cannot redeclare block-scoped variable 'var8'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(24,13): error TS2451: Cannot redeclare block-scoped variable 'var8'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(25,15): error TS2451: Cannot redeclare block-scoped variable 'var8'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(31,13): error TS2451: Cannot redeclare block-scoped variable 'var9'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(32,13): error TS2451: Cannot redeclare block-scoped variable 'var9'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(33,13): error TS2451: Cannot redeclare block-scoped variable 'var9'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(36,11): error TS2451: Cannot redeclare block-scoped variable 'var10'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(37,11): error TS2451: Cannot redeclare block-scoped variable 'var10'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(38,11): error TS2451: Cannot redeclare block-scoped variable 'var10'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(40,9): error TS2451: Cannot redeclare block-scoped variable 'var11'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(41,9): error TS2451: Cannot redeclare block-scoped variable 'var11'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(42,9): error TS2451: Cannot redeclare block-scoped variable 'var11'. +tests/cases/compiler/letDeclarations-scopes-duplicates.ts(45,9): error TS2451: Cannot redeclare block-scoped variable 'var12'. tests/cases/compiler/letDeclarations-scopes-duplicates.ts(46,9): error TS2451: Cannot redeclare block-scoped variable 'var12'. -tests/cases/compiler/letDeclarations-scopes-duplicates.ts(47,9): error TS2451: Cannot redeclare block-scoped variable 'var12'. ==== tests/cases/compiler/letDeclarations-scopes-duplicates.ts (24 errors) ==== - // Errors: redeclaration let var1 = 0; ~~~~ diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates.js b/tests/baselines/reference/letDeclarations-scopes-duplicates.js index c7d2ef9863a04..4318af73c5b67 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates.js @@ -1,5 +1,4 @@ //// [letDeclarations-scopes-duplicates.ts] - // Errors: redeclaration let var1 = 0; let var1 = 0; // error diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates2.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates2.errors.txt index 72b8b5609b695..6b07619781618 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates2.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - let var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates2.js b/tests/baselines/reference/letDeclarations-scopes-duplicates2.js index 9b35bd81c76fa..0647b4ac12784 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates2.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates2.ts] //// //// [file1.ts] - let var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates3.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates3.errors.txt index 6ed2fb66195ba..2ce3fd1c41a66 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates3.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - let var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates3.js b/tests/baselines/reference/letDeclarations-scopes-duplicates3.js index e74caf37219a1..ece7c74046299 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates3.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates3.ts] //// //// [file1.ts] - let var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates4.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates4.errors.txt index ec87809b0cda5..b276d6a35151a 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates4.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates4.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - const var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates4.js b/tests/baselines/reference/letDeclarations-scopes-duplicates4.js index ac338e31c7291..68d31e011d659 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates4.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates4.ts] //// //// [file1.ts] - const var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates5.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates5.errors.txt index ce3a9da598a4a..09955c14bc019 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates5.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,7): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - const var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates5.js b/tests/baselines/reference/letDeclarations-scopes-duplicates5.js index 2424c91ab90dd..524a1f0e1164e 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates5.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates5.ts] //// //// [file1.ts] - const var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates6.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates6.errors.txt index d09eda28075d8..1d39bcde276c1 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates6.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - var var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates6.js b/tests/baselines/reference/letDeclarations-scopes-duplicates6.js index 24edc0b7bde49..ba4aeed7d8af9 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates6.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates6.ts] //// //// [file1.ts] - var var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates7.errors.txt b/tests/baselines/reference/letDeclarations-scopes-duplicates7.errors.txt index dad85f9f81946..bead743dc4ef3 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates7.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates7.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/file1.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. +tests/cases/compiler/file1.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. tests/cases/compiler/file2.ts(1,5): error TS2451: Cannot redeclare block-scoped variable 'var1'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - let var1 = 0; ~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'var1'. diff --git a/tests/baselines/reference/letDeclarations-scopes-duplicates7.js b/tests/baselines/reference/letDeclarations-scopes-duplicates7.js index 4cbc359e2c255..e11a51d31d896 100644 --- a/tests/baselines/reference/letDeclarations-scopes-duplicates7.js +++ b/tests/baselines/reference/letDeclarations-scopes-duplicates7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-scopes-duplicates7.ts] //// //// [file1.ts] - let var1 = 0; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-scopes.errors.txt b/tests/baselines/reference/letDeclarations-scopes.errors.txt index a44f6a90f7afc..90896f1f895fc 100644 --- a/tests/baselines/reference/letDeclarations-scopes.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes.errors.txt @@ -1,9 +1,7 @@ -tests/cases/compiler/letDeclarations-scopes.ts(29,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/letDeclarations-scopes.ts(27,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. ==== tests/cases/compiler/letDeclarations-scopes.ts (1 errors) ==== - - // global let l = "string"; diff --git a/tests/baselines/reference/letDeclarations-scopes.js b/tests/baselines/reference/letDeclarations-scopes.js index 3fc5976b4b700..9d6d9acb3d971 100644 --- a/tests/baselines/reference/letDeclarations-scopes.js +++ b/tests/baselines/reference/letDeclarations-scopes.js @@ -1,6 +1,4 @@ //// [letDeclarations-scopes.ts] - - // global let l = "string"; diff --git a/tests/baselines/reference/letDeclarations-scopes2.errors.txt b/tests/baselines/reference/letDeclarations-scopes2.errors.txt index a786db1104b79..8e0cf04aa1416 100644 --- a/tests/baselines/reference/letDeclarations-scopes2.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes2.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/letDeclarations-scopes2.ts(9,5): error TS2304: Cannot find name 'local2'. -tests/cases/compiler/letDeclarations-scopes2.ts(21,5): error TS2304: Cannot find name 'local2'. -tests/cases/compiler/letDeclarations-scopes2.ts(24,1): error TS2304: Cannot find name 'local'. -tests/cases/compiler/letDeclarations-scopes2.ts(26,1): error TS2304: Cannot find name 'local2'. +tests/cases/compiler/letDeclarations-scopes2.ts(8,5): error TS2304: Cannot find name 'local2'. +tests/cases/compiler/letDeclarations-scopes2.ts(20,5): error TS2304: Cannot find name 'local2'. +tests/cases/compiler/letDeclarations-scopes2.ts(23,1): error TS2304: Cannot find name 'local'. +tests/cases/compiler/letDeclarations-scopes2.ts(25,1): error TS2304: Cannot find name 'local2'. ==== tests/cases/compiler/letDeclarations-scopes2.ts (4 errors) ==== - let global = 0; { diff --git a/tests/baselines/reference/letDeclarations-scopes2.js b/tests/baselines/reference/letDeclarations-scopes2.js index 98d0e791832e0..c21d7f4671f0e 100644 --- a/tests/baselines/reference/letDeclarations-scopes2.js +++ b/tests/baselines/reference/letDeclarations-scopes2.js @@ -1,5 +1,4 @@ //// [letDeclarations-scopes2.ts] - let global = 0; { diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition.errors.txt b/tests/baselines/reference/letDeclarations-useBeforeDefinition.errors.txt index 74c354f4ff26f..69721a93b6339 100644 --- a/tests/baselines/reference/letDeclarations-useBeforeDefinition.errors.txt +++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letDeclarations-useBeforeDefinition.ts(3,5): error TS2448: Block-scoped variable 'l1' used before its declaration. -tests/cases/compiler/letDeclarations-useBeforeDefinition.ts(9,5): error TS2448: Block-scoped variable 'v1' used before its declaration. +tests/cases/compiler/letDeclarations-useBeforeDefinition.ts(2,5): error TS2448: Block-scoped variable 'l1' used before its declaration. +tests/cases/compiler/letDeclarations-useBeforeDefinition.ts(8,5): error TS2448: Block-scoped variable 'v1' used before its declaration. ==== tests/cases/compiler/letDeclarations-useBeforeDefinition.ts (2 errors) ==== - { l1; ~~ diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition.js b/tests/baselines/reference/letDeclarations-useBeforeDefinition.js index be1f9a127f49a..52c37633b67c4 100644 --- a/tests/baselines/reference/letDeclarations-useBeforeDefinition.js +++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition.js @@ -1,5 +1,4 @@ //// [letDeclarations-useBeforeDefinition.ts] - { l1; let l1; diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt index 5b8633312d9a9..8820af5cc7c04 100644 --- a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt +++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/file1.ts(2,1): error TS2448: Block-scoped variable 'l' used before its declaration. +tests/cases/compiler/file1.ts(1,1): error TS2448: Block-scoped variable 'l' used before its declaration. ==== tests/cases/compiler/file1.ts (1 errors) ==== - l; ~ !!! error TS2448: Block-scoped variable 'l' used before its declaration. diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.js b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.js index 35560edd1c887..515ef338dda3f 100644 --- a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.js +++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/letDeclarations-useBeforeDefinition2.ts] //// //// [file1.ts] - l; //// [file2.ts] diff --git a/tests/baselines/reference/letDeclarations-validContexts.errors.txt b/tests/baselines/reference/letDeclarations-validContexts.errors.txt index dfd60c7ee5392..9613472541ca0 100644 --- a/tests/baselines/reference/letDeclarations-validContexts.errors.txt +++ b/tests/baselines/reference/letDeclarations-validContexts.errors.txt @@ -1,10 +1,7 @@ -tests/cases/compiler/letDeclarations-validContexts.ts(21,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. +tests/cases/compiler/letDeclarations-validContexts.ts(18,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'. ==== tests/cases/compiler/letDeclarations-validContexts.ts (1 errors) ==== - - - // Control flow statements with blocks if (true) { let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations-validContexts.js b/tests/baselines/reference/letDeclarations-validContexts.js index 1859a0215bb21..94d9bed15541e 100644 --- a/tests/baselines/reference/letDeclarations-validContexts.js +++ b/tests/baselines/reference/letDeclarations-validContexts.js @@ -1,7 +1,4 @@ //// [letDeclarations-validContexts.ts] - - - // Control flow statements with blocks if (true) { let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations.js b/tests/baselines/reference/letDeclarations.js index 8acb82204e340..7ad1bf8f2b3a1 100644 --- a/tests/baselines/reference/letDeclarations.js +++ b/tests/baselines/reference/letDeclarations.js @@ -1,5 +1,4 @@ //// [letDeclarations.ts] - let l1; let l2: number; let l3, l4, l5 :string, l6; diff --git a/tests/baselines/reference/letDeclarations.symbols b/tests/baselines/reference/letDeclarations.symbols index dbbaac211ac73..e4c7ed54748e8 100644 --- a/tests/baselines/reference/letDeclarations.symbols +++ b/tests/baselines/reference/letDeclarations.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/letDeclarations.ts === - let l1; ->l1 : Symbol(l1, Decl(letDeclarations.ts, 1, 3)) +>l1 : Symbol(l1, Decl(letDeclarations.ts, 0, 3)) let l2: number; ->l2 : Symbol(l2, Decl(letDeclarations.ts, 2, 3)) +>l2 : Symbol(l2, Decl(letDeclarations.ts, 1, 3)) let l3, l4, l5 :string, l6; ->l3 : Symbol(l3, Decl(letDeclarations.ts, 3, 3)) ->l4 : Symbol(l4, Decl(letDeclarations.ts, 3, 7)) ->l5 : Symbol(l5, Decl(letDeclarations.ts, 3, 11)) ->l6 : Symbol(l6, Decl(letDeclarations.ts, 3, 23)) +>l3 : Symbol(l3, Decl(letDeclarations.ts, 2, 3)) +>l4 : Symbol(l4, Decl(letDeclarations.ts, 2, 7)) +>l5 : Symbol(l5, Decl(letDeclarations.ts, 2, 11)) +>l6 : Symbol(l6, Decl(letDeclarations.ts, 2, 23)) let l7 = false; ->l7 : Symbol(l7, Decl(letDeclarations.ts, 5, 3)) +>l7 : Symbol(l7, Decl(letDeclarations.ts, 4, 3)) let l8: number = 23; ->l8 : Symbol(l8, Decl(letDeclarations.ts, 6, 3)) +>l8 : Symbol(l8, Decl(letDeclarations.ts, 5, 3)) let l9 = 0, l10 :string = "", l11 = null; ->l9 : Symbol(l9, Decl(letDeclarations.ts, 7, 3)) ->l10 : Symbol(l10, Decl(letDeclarations.ts, 7, 11)) ->l11 : Symbol(l11, Decl(letDeclarations.ts, 7, 29)) +>l9 : Symbol(l9, Decl(letDeclarations.ts, 6, 3)) +>l10 : Symbol(l10, Decl(letDeclarations.ts, 6, 11)) +>l11 : Symbol(l11, Decl(letDeclarations.ts, 6, 29)) for(let l11 in {}) { } ->l11 : Symbol(l11, Decl(letDeclarations.ts, 9, 7)) +>l11 : Symbol(l11, Decl(letDeclarations.ts, 8, 7)) for(let l12 = 0; l12 < 9; l12++) { } ->l12 : Symbol(l12, Decl(letDeclarations.ts, 11, 7)) ->l12 : Symbol(l12, Decl(letDeclarations.ts, 11, 7)) ->l12 : Symbol(l12, Decl(letDeclarations.ts, 11, 7)) +>l12 : Symbol(l12, Decl(letDeclarations.ts, 10, 7)) +>l12 : Symbol(l12, Decl(letDeclarations.ts, 10, 7)) +>l12 : Symbol(l12, Decl(letDeclarations.ts, 10, 7)) diff --git a/tests/baselines/reference/letDeclarations.types b/tests/baselines/reference/letDeclarations.types index b1548f788effe..536d6ea3a7aa7 100644 --- a/tests/baselines/reference/letDeclarations.types +++ b/tests/baselines/reference/letDeclarations.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letDeclarations.ts === - let l1; >l1 : any diff --git a/tests/baselines/reference/letDeclarations2.js b/tests/baselines/reference/letDeclarations2.js index 8a6f039f2ca93..c8b0216fce41f 100644 --- a/tests/baselines/reference/letDeclarations2.js +++ b/tests/baselines/reference/letDeclarations2.js @@ -1,5 +1,4 @@ //// [letDeclarations2.ts] - module M { let l1 = "s"; export let l2 = 0; diff --git a/tests/baselines/reference/letDeclarations2.symbols b/tests/baselines/reference/letDeclarations2.symbols index 1f4bcb1242042..9adb352a5c83a 100644 --- a/tests/baselines/reference/letDeclarations2.symbols +++ b/tests/baselines/reference/letDeclarations2.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letDeclarations2.ts === - module M { >M : Symbol(M, Decl(letDeclarations2.ts, 0, 0)) let l1 = "s"; ->l1 : Symbol(l1, Decl(letDeclarations2.ts, 2, 7)) +>l1 : Symbol(l1, Decl(letDeclarations2.ts, 1, 7)) export let l2 = 0; ->l2 : Symbol(l2, Decl(letDeclarations2.ts, 3, 14)) +>l2 : Symbol(l2, Decl(letDeclarations2.ts, 2, 14)) } diff --git a/tests/baselines/reference/letDeclarations2.types b/tests/baselines/reference/letDeclarations2.types index 893514adb3f32..6648957e3d766 100644 --- a/tests/baselines/reference/letDeclarations2.types +++ b/tests/baselines/reference/letDeclarations2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letDeclarations2.ts === - module M { >M : typeof M diff --git a/tests/baselines/reference/letInConstDeclarations_ES5.errors.txt b/tests/baselines/reference/letInConstDeclarations_ES5.errors.txt index 8b694c35dbbf0..bcb42048cb928 100644 --- a/tests/baselines/reference/letInConstDeclarations_ES5.errors.txt +++ b/tests/baselines/reference/letInConstDeclarations_ES5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letInConstDeclarations_ES5.ts(3,15): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInConstDeclarations_ES5.ts(6,19): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInConstDeclarations_ES5.ts(2,15): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInConstDeclarations_ES5.ts(5,19): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInConstDeclarations_ES5.ts (2 errors) ==== - // All use of let in const declaration should be an error const x = 50, let = 5; ~~~ diff --git a/tests/baselines/reference/letInConstDeclarations_ES5.js b/tests/baselines/reference/letInConstDeclarations_ES5.js index f76d49765f03a..b92ea8852a91c 100644 --- a/tests/baselines/reference/letInConstDeclarations_ES5.js +++ b/tests/baselines/reference/letInConstDeclarations_ES5.js @@ -1,5 +1,4 @@ //// [letInConstDeclarations_ES5.ts] - // All use of let in const declaration should be an error const x = 50, let = 5; diff --git a/tests/baselines/reference/letInConstDeclarations_ES6.errors.txt b/tests/baselines/reference/letInConstDeclarations_ES6.errors.txt index d29f78be01409..c14bb5de7e6ec 100644 --- a/tests/baselines/reference/letInConstDeclarations_ES6.errors.txt +++ b/tests/baselines/reference/letInConstDeclarations_ES6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letInConstDeclarations_ES6.ts(3,15): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInConstDeclarations_ES6.ts(6,19): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInConstDeclarations_ES6.ts(2,15): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInConstDeclarations_ES6.ts(5,19): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInConstDeclarations_ES6.ts (2 errors) ==== - // All use of let in const declaration should be an error const x = 50, let = 5; ~~~ diff --git a/tests/baselines/reference/letInConstDeclarations_ES6.js b/tests/baselines/reference/letInConstDeclarations_ES6.js index f209ef1dede4a..3dc25e88ac03b 100644 --- a/tests/baselines/reference/letInConstDeclarations_ES6.js +++ b/tests/baselines/reference/letInConstDeclarations_ES6.js @@ -1,5 +1,4 @@ //// [letInConstDeclarations_ES6.ts] - // All use of let in const declaration should be an error const x = 50, let = 5; diff --git a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.errors.txt b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.errors.txt index e335a9652f4da..dfc98387e09b3 100644 --- a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.errors.txt +++ b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.errors.txt @@ -1,15 +1,14 @@ -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(3,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(5,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(7,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(9,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(12,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(14,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(16,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(18,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(2,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(4,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(6,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(8,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(11,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(13,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(15,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts(17,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES5.ts (8 errors) ==== - // Should be an error for (let let of [1,2,3]) {} ~~~ diff --git a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.js b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.js index 4c46717649285..1ce535b095b4c 100644 --- a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.js +++ b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.js @@ -1,5 +1,4 @@ //// [letInLetConstDeclOfForOfAndForIn_ES5.ts] - // Should be an error for (let let of [1,2,3]) {} diff --git a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.errors.txt b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.errors.txt index 1a5af892b7425..c7980686a0714 100644 --- a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.errors.txt +++ b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.errors.txt @@ -1,15 +1,14 @@ -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(3,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(5,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(7,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(9,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(12,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(14,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(16,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(18,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(2,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(4,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(6,10): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(8,12): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(11,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(13,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(15,11): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts(17,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInLetConstDeclOfForOfAndForIn_ES6.ts (8 errors) ==== - // Should be an error for (let let of [1,2,3]) {} ~~~ diff --git a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.js b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.js index 583dc936871c3..fdcce5aca062b 100644 --- a/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.js +++ b/tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.js @@ -1,5 +1,4 @@ //// [letInLetConstDeclOfForOfAndForIn_ES6.ts] - // Should be an error for (let let of [1,2,3]) {} diff --git a/tests/baselines/reference/letInLetDeclarations_ES5.errors.txt b/tests/baselines/reference/letInLetDeclarations_ES5.errors.txt index 73f824dd7deb2..f359c60df9dcf 100644 --- a/tests/baselines/reference/letInLetDeclarations_ES5.errors.txt +++ b/tests/baselines/reference/letInLetDeclarations_ES5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letInLetDeclarations_ES5.ts(3,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetDeclarations_ES5.ts(6,17): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetDeclarations_ES5.ts(2,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetDeclarations_ES5.ts(5,17): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInLetDeclarations_ES5.ts (2 errors) ==== - // All use of let in const declaration should be an error let x = 50, let = 5; ~~~ diff --git a/tests/baselines/reference/letInLetDeclarations_ES5.js b/tests/baselines/reference/letInLetDeclarations_ES5.js index 0b7f02150a48b..03b73e95e1994 100644 --- a/tests/baselines/reference/letInLetDeclarations_ES5.js +++ b/tests/baselines/reference/letInLetDeclarations_ES5.js @@ -1,5 +1,4 @@ //// [letInLetDeclarations_ES5.ts] - // All use of let in const declaration should be an error let x = 50, let = 5; diff --git a/tests/baselines/reference/letInLetDeclarations_ES6.errors.txt b/tests/baselines/reference/letInLetDeclarations_ES6.errors.txt index 0fe1aa882e92e..fa2372ea009f3 100644 --- a/tests/baselines/reference/letInLetDeclarations_ES6.errors.txt +++ b/tests/baselines/reference/letInLetDeclarations_ES6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/letInLetDeclarations_ES6.ts(3,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. -tests/cases/compiler/letInLetDeclarations_ES6.ts(6,17): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetDeclarations_ES6.ts(2,13): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. +tests/cases/compiler/letInLetDeclarations_ES6.ts(5,17): error TS2480: 'let' is not allowed to be used as a name in 'let' or 'const' declarations. ==== tests/cases/compiler/letInLetDeclarations_ES6.ts (2 errors) ==== - // All use of let in const declaration should be an error let x = 50, let = 5; ~~~ diff --git a/tests/baselines/reference/letInLetDeclarations_ES6.js b/tests/baselines/reference/letInLetDeclarations_ES6.js index 7c4385cd4d9be..35bbef9f2d311 100644 --- a/tests/baselines/reference/letInLetDeclarations_ES6.js +++ b/tests/baselines/reference/letInLetDeclarations_ES6.js @@ -1,5 +1,4 @@ //// [letInLetDeclarations_ES6.ts] - // All use of let in const declaration should be an error let x = 50, let = 5; diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES5.js b/tests/baselines/reference/letInVarDeclOfForIn_ES5.js index 2cef7610199f4..36de180f10d1a 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES5.js +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES5.js @@ -1,5 +1,4 @@ //// [letInVarDeclOfForIn_ES5.ts] - // should not be an error for (var let in [1,2,3]) {} diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES5.symbols b/tests/baselines/reference/letInVarDeclOfForIn_ES5.symbols index cbfd0f58086df..1870128b084c5 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES5.symbols +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES5.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letInVarDeclOfForIn_ES5.ts === - // should not be an error for (var let in [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForIn_ES5.ts, 2, 8), Decl(letInVarDeclOfForIn_ES5.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForIn_ES5.ts, 1, 8), Decl(letInVarDeclOfForIn_ES5.ts, 4, 9)) { for (var let in [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForIn_ES5.ts, 2, 8), Decl(letInVarDeclOfForIn_ES5.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForIn_ES5.ts, 1, 8), Decl(letInVarDeclOfForIn_ES5.ts, 4, 9)) } diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES5.types b/tests/baselines/reference/letInVarDeclOfForIn_ES5.types index d3751f5895950..ddb78832d5b00 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES5.types +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letInVarDeclOfForIn_ES5.ts === - // should not be an error for (var let in [1,2,3]) {} >let : string diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES6.js b/tests/baselines/reference/letInVarDeclOfForIn_ES6.js index 1cf6850f58864..140887e06c9b0 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES6.js +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES6.js @@ -1,5 +1,4 @@ //// [letInVarDeclOfForIn_ES6.ts] - // should not be an error for (var let in [1,2,3]) {} diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES6.symbols b/tests/baselines/reference/letInVarDeclOfForIn_ES6.symbols index 3b3e68e3040f1..d4757a6a29372 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES6.symbols +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letInVarDeclOfForIn_ES6.ts === - // should not be an error for (var let in [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForIn_ES6.ts, 2, 8), Decl(letInVarDeclOfForIn_ES6.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForIn_ES6.ts, 1, 8), Decl(letInVarDeclOfForIn_ES6.ts, 4, 9)) { for (var let in [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForIn_ES6.ts, 2, 8), Decl(letInVarDeclOfForIn_ES6.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForIn_ES6.ts, 1, 8), Decl(letInVarDeclOfForIn_ES6.ts, 4, 9)) } diff --git a/tests/baselines/reference/letInVarDeclOfForIn_ES6.types b/tests/baselines/reference/letInVarDeclOfForIn_ES6.types index 1d672c12ea67f..1db8d6b5bab24 100644 --- a/tests/baselines/reference/letInVarDeclOfForIn_ES6.types +++ b/tests/baselines/reference/letInVarDeclOfForIn_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letInVarDeclOfForIn_ES6.ts === - // should not be an error for (var let in [1,2,3]) {} >let : string diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES5.js b/tests/baselines/reference/letInVarDeclOfForOf_ES5.js index cdc374fbea061..90c203b47ad91 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES5.js +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES5.js @@ -1,5 +1,4 @@ //// [letInVarDeclOfForOf_ES5.ts] - // should not be an error for (var let of [1,2,3]) {} diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES5.symbols b/tests/baselines/reference/letInVarDeclOfForOf_ES5.symbols index f5411cfca2dae..ae9433da1e780 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES5.symbols +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES5.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letInVarDeclOfForOf_ES5.ts === - // should not be an error for (var let of [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForOf_ES5.ts, 2, 8), Decl(letInVarDeclOfForOf_ES5.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForOf_ES5.ts, 1, 8), Decl(letInVarDeclOfForOf_ES5.ts, 4, 9)) { for (var let of [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForOf_ES5.ts, 2, 8), Decl(letInVarDeclOfForOf_ES5.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForOf_ES5.ts, 1, 8), Decl(letInVarDeclOfForOf_ES5.ts, 4, 9)) } diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES5.types b/tests/baselines/reference/letInVarDeclOfForOf_ES5.types index 6b1648dcaf364..642de2e833716 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES5.types +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letInVarDeclOfForOf_ES5.ts === - // should not be an error for (var let of [1,2,3]) {} >let : number diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES6.js b/tests/baselines/reference/letInVarDeclOfForOf_ES6.js index fca365c4b0d7c..867e2cbab613c 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES6.js +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES6.js @@ -1,5 +1,4 @@ //// [letInVarDeclOfForOf_ES6.ts] - // should not be an error for (var let of [1,2,3]) {} diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES6.symbols b/tests/baselines/reference/letInVarDeclOfForOf_ES6.symbols index d4c14eff0b091..6b632793ef704 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES6.symbols +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES6.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/letInVarDeclOfForOf_ES6.ts === - // should not be an error for (var let of [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForOf_ES6.ts, 2, 8), Decl(letInVarDeclOfForOf_ES6.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForOf_ES6.ts, 1, 8), Decl(letInVarDeclOfForOf_ES6.ts, 4, 9)) { for (var let of [1,2,3]) {} ->let : Symbol(let, Decl(letInVarDeclOfForOf_ES6.ts, 2, 8), Decl(letInVarDeclOfForOf_ES6.ts, 5, 9)) +>let : Symbol(let, Decl(letInVarDeclOfForOf_ES6.ts, 1, 8), Decl(letInVarDeclOfForOf_ES6.ts, 4, 9)) } diff --git a/tests/baselines/reference/letInVarDeclOfForOf_ES6.types b/tests/baselines/reference/letInVarDeclOfForOf_ES6.types index 3231dbc0b2c33..8e114def98eac 100644 --- a/tests/baselines/reference/letInVarDeclOfForOf_ES6.types +++ b/tests/baselines/reference/letInVarDeclOfForOf_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/letInVarDeclOfForOf_ES6.ts === - // should not be an error for (var let of [1,2,3]) {} >let : number diff --git a/tests/baselines/reference/library-reference-1.js b/tests/baselines/reference/library-reference-1.js index e709db72deabf..2533b8ae79ee8 100644 --- a/tests/baselines/reference/library-reference-1.js +++ b/tests/baselines/reference/library-reference-1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-1.ts] //// //// [index.d.ts] - // We can find typings in the ./types folder declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-1.symbols b/tests/baselines/reference/library-reference-1.symbols index 14a6b115009e4..14a539f7848e7 100644 --- a/tests/baselines/reference/library-reference-1.symbols +++ b/tests/baselines/reference/library-reference-1.symbols @@ -1,16 +1,15 @@ === /src/consumer.ts === /// $.foo(); ->$.foo : Symbol(foo, Decl(index.d.ts, 3, 16)) ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$.foo : Symbol(foo, Decl(index.d.ts, 2, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) === /src/types/jquery/index.d.ts === - // We can find typings in the ./types folder declare var $: { foo(): void }; ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) diff --git a/tests/baselines/reference/library-reference-1.types b/tests/baselines/reference/library-reference-1.types index c247e94617e40..851520a146236 100644 --- a/tests/baselines/reference/library-reference-1.types +++ b/tests/baselines/reference/library-reference-1.types @@ -7,7 +7,6 @@ $.foo(); >foo : () => void === /src/types/jquery/index.d.ts === - // We can find typings in the ./types folder declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-10.js b/tests/baselines/reference/library-reference-10.js index a6dbdfce6106e..f682c9ccc2f41 100644 --- a/tests/baselines/reference/library-reference-10.js +++ b/tests/baselines/reference/library-reference-10.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-10.ts] //// //// [package.json] - // package.json in a primary reference can refer to another file { diff --git a/tests/baselines/reference/library-reference-11.js b/tests/baselines/reference/library-reference-11.js index 773fe5a890a89..e070f82805d1f 100644 --- a/tests/baselines/reference/library-reference-11.js +++ b/tests/baselines/reference/library-reference-11.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-11.ts] //// //// [package.json] - // package.json in a secondary reference can refer to another file { diff --git a/tests/baselines/reference/library-reference-12.js b/tests/baselines/reference/library-reference-12.js index 42d0f650b50d1..77f5da776ce8a 100644 --- a/tests/baselines/reference/library-reference-12.js +++ b/tests/baselines/reference/library-reference-12.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-12.ts] //// //// [package.json] - // package.json in a secondary reference can refer to another file { diff --git a/tests/baselines/reference/library-reference-14.js b/tests/baselines/reference/library-reference-14.js index 0fb5ff04fb9be..03ac3fab8256d 100644 --- a/tests/baselines/reference/library-reference-14.js +++ b/tests/baselines/reference/library-reference-14.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-14.ts] //// //// [index.d.ts] - declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-14.symbols b/tests/baselines/reference/library-reference-14.symbols index 162afc50ca785..04d50373caae0 100644 --- a/tests/baselines/reference/library-reference-14.symbols +++ b/tests/baselines/reference/library-reference-14.symbols @@ -1,13 +1,12 @@ === /a/b/consumer.ts === $.foo(); ->$.foo : Symbol(foo, Decl(index.d.ts, 1, 16)) ->$ : Symbol($, Decl(index.d.ts, 1, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 1, 16)) +>$.foo : Symbol(foo, Decl(index.d.ts, 0, 16)) +>$ : Symbol($, Decl(index.d.ts, 0, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 0, 16)) === /a/types/jquery/index.d.ts === - declare var $: { foo(): void }; ->$ : Symbol($, Decl(index.d.ts, 1, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 1, 16)) +>$ : Symbol($, Decl(index.d.ts, 0, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 0, 16)) diff --git a/tests/baselines/reference/library-reference-14.types b/tests/baselines/reference/library-reference-14.types index f4196e10744e2..b00d778c5b2a2 100644 --- a/tests/baselines/reference/library-reference-14.types +++ b/tests/baselines/reference/library-reference-14.types @@ -6,7 +6,6 @@ $.foo(); >foo : () => void === /a/types/jquery/index.d.ts === - declare var $: { foo(): void }; >$ : { foo(): void; } >foo : () => void diff --git a/tests/baselines/reference/library-reference-15.errors.txt b/tests/baselines/reference/library-reference-15.errors.txt index 9586ba8bc724a..f4cee66d1a1da 100644 --- a/tests/baselines/reference/library-reference-15.errors.txt +++ b/tests/baselines/reference/library-reference-15.errors.txt @@ -7,7 +7,6 @@ ~~ !!! error TS2304: Cannot find name '$2'. ==== /a/types/jquery/index.d.ts (0 errors) ==== - declare var $: { foo(): void }; ==== /a/types/jquery2/index.d.ts (0 errors) ==== diff --git a/tests/baselines/reference/library-reference-15.js b/tests/baselines/reference/library-reference-15.js index c1caa0c45e75a..bdbf0c9a1c21b 100644 --- a/tests/baselines/reference/library-reference-15.js +++ b/tests/baselines/reference/library-reference-15.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-15.ts] //// //// [index.d.ts] - declare var $: { foo(): void }; //// [index.d.ts] diff --git a/tests/baselines/reference/library-reference-2.js b/tests/baselines/reference/library-reference-2.js index 20729db6c6032..311b928a5bdb5 100644 --- a/tests/baselines/reference/library-reference-2.js +++ b/tests/baselines/reference/library-reference-2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-2.ts] //// //// [package.json] - // package.json in a primary reference can refer to another file { diff --git a/tests/baselines/reference/library-reference-3.js b/tests/baselines/reference/library-reference-3.js index 6f9ad2d43d2cb..687a3c8f8acf2 100644 --- a/tests/baselines/reference/library-reference-3.js +++ b/tests/baselines/reference/library-reference-3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-3.ts] //// //// [index.d.ts] - // Secondary references are possible declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-3.symbols b/tests/baselines/reference/library-reference-3.symbols index a1785fd77c9a5..c49d48f315ea1 100644 --- a/tests/baselines/reference/library-reference-3.symbols +++ b/tests/baselines/reference/library-reference-3.symbols @@ -1,15 +1,14 @@ === /src/consumer.ts === /// $.foo(); ->$.foo : Symbol(foo, Decl(index.d.ts, 3, 16)) ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$.foo : Symbol(foo, Decl(index.d.ts, 2, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) === /src/node_modules/jquery/index.d.ts === - // Secondary references are possible declare var $: { foo(): void }; ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) diff --git a/tests/baselines/reference/library-reference-3.types b/tests/baselines/reference/library-reference-3.types index ed7da59525f32..10fd29c4d5fd7 100644 --- a/tests/baselines/reference/library-reference-3.types +++ b/tests/baselines/reference/library-reference-3.types @@ -7,7 +7,6 @@ $.foo(); >foo : () => void === /src/node_modules/jquery/index.d.ts === - // Secondary references are possible declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-4.js b/tests/baselines/reference/library-reference-4.js index 39e4b1d73a57a..e4f4bf4996a40 100644 --- a/tests/baselines/reference/library-reference-4.js +++ b/tests/baselines/reference/library-reference-4.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-4.ts] //// //// [index.d.ts] - // Secondary references may be duplicated if they agree in content /// diff --git a/tests/baselines/reference/library-reference-4.symbols b/tests/baselines/reference/library-reference-4.symbols index f7c082a946d1a..37a0e267d002b 100644 --- a/tests/baselines/reference/library-reference-4.symbols +++ b/tests/baselines/reference/library-reference-4.symbols @@ -3,12 +3,11 @@ No type information for this code./// No type information for this code. No type information for this code.=== /node_modules/foo/index.d.ts === - // Secondary references may be duplicated if they agree in content /// declare var foo: any; ->foo : Symbol(foo, Decl(index.d.ts, 4, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 3, 11)) === /node_modules/foo/node_modules/alpha/index.d.ts === declare var alpha: any; diff --git a/tests/baselines/reference/library-reference-4.types b/tests/baselines/reference/library-reference-4.types index a0a7d370b4cdf..329ad50995fe1 100644 --- a/tests/baselines/reference/library-reference-4.types +++ b/tests/baselines/reference/library-reference-4.types @@ -3,7 +3,6 @@ No type information for this code./// No type information for this code. No type information for this code.=== /node_modules/foo/index.d.ts === - // Secondary references may be duplicated if they agree in content /// diff --git a/tests/baselines/reference/library-reference-5.errors.txt b/tests/baselines/reference/library-reference-5.errors.txt index c23b49c61de89..2130b1ce037fc 100644 --- a/tests/baselines/reference/library-reference-5.errors.txt +++ b/tests/baselines/reference/library-reference-5.errors.txt @@ -6,7 +6,6 @@ /// ==== /node_modules/foo/index.d.ts (0 errors) ==== - // Secondary references may not be duplicated if they disagree in content /// diff --git a/tests/baselines/reference/library-reference-5.js b/tests/baselines/reference/library-reference-5.js index 40d2131920e3a..0f39b31300f8d 100644 --- a/tests/baselines/reference/library-reference-5.js +++ b/tests/baselines/reference/library-reference-5.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-5.ts] //// //// [index.d.ts] - // Secondary references may not be duplicated if they disagree in content /// diff --git a/tests/baselines/reference/library-reference-6.js b/tests/baselines/reference/library-reference-6.js index d78a3a131a1ce..af364b31c4ee0 100644 --- a/tests/baselines/reference/library-reference-6.js +++ b/tests/baselines/reference/library-reference-6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-6.ts] //// //// [index.d.ts] - // The primary lookup folder is relative to tsconfig.json, if present declare var alpha: { a: string }; diff --git a/tests/baselines/reference/library-reference-6.symbols b/tests/baselines/reference/library-reference-6.symbols index 595d43df3faec..086795e85d4c0 100644 --- a/tests/baselines/reference/library-reference-6.symbols +++ b/tests/baselines/reference/library-reference-6.symbols @@ -2,15 +2,14 @@ /// var x: string = alpha.a; >x : Symbol(x, Decl(foo.ts, 1, 3)) ->alpha.a : Symbol(a, Decl(index.d.ts, 3, 20)) ->alpha : Symbol(alpha, Decl(index.d.ts, 3, 11)) ->a : Symbol(a, Decl(index.d.ts, 3, 20)) +>alpha.a : Symbol(a, Decl(index.d.ts, 2, 20)) +>alpha : Symbol(alpha, Decl(index.d.ts, 2, 11)) +>a : Symbol(a, Decl(index.d.ts, 2, 20)) === /node_modules/@types/alpha/index.d.ts === - // The primary lookup folder is relative to tsconfig.json, if present declare var alpha: { a: string }; ->alpha : Symbol(alpha, Decl(index.d.ts, 3, 11)) ->a : Symbol(a, Decl(index.d.ts, 3, 20)) +>alpha : Symbol(alpha, Decl(index.d.ts, 2, 11)) +>a : Symbol(a, Decl(index.d.ts, 2, 20)) diff --git a/tests/baselines/reference/library-reference-6.types b/tests/baselines/reference/library-reference-6.types index e2762c0943a9b..0dd804f83198e 100644 --- a/tests/baselines/reference/library-reference-6.types +++ b/tests/baselines/reference/library-reference-6.types @@ -7,7 +7,6 @@ var x: string = alpha.a; >a : string === /node_modules/@types/alpha/index.d.ts === - // The primary lookup folder is relative to tsconfig.json, if present declare var alpha: { a: string }; diff --git a/tests/baselines/reference/library-reference-7.js b/tests/baselines/reference/library-reference-7.js index f1ef6ca4eab8a..dddd8fcc8ccb5 100644 --- a/tests/baselines/reference/library-reference-7.js +++ b/tests/baselines/reference/library-reference-7.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-7.ts] //// //// [index.d.ts] - // Secondary references are possible declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-7.symbols b/tests/baselines/reference/library-reference-7.symbols index a1785fd77c9a5..c49d48f315ea1 100644 --- a/tests/baselines/reference/library-reference-7.symbols +++ b/tests/baselines/reference/library-reference-7.symbols @@ -1,15 +1,14 @@ === /src/consumer.ts === /// $.foo(); ->$.foo : Symbol(foo, Decl(index.d.ts, 3, 16)) ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$.foo : Symbol(foo, Decl(index.d.ts, 2, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) === /src/node_modules/jquery/index.d.ts === - // Secondary references are possible declare var $: { foo(): void }; ->$ : Symbol($, Decl(index.d.ts, 3, 11)) ->foo : Symbol(foo, Decl(index.d.ts, 3, 16)) +>$ : Symbol($, Decl(index.d.ts, 2, 11)) +>foo : Symbol(foo, Decl(index.d.ts, 2, 16)) diff --git a/tests/baselines/reference/library-reference-7.types b/tests/baselines/reference/library-reference-7.types index ed7da59525f32..10fd29c4d5fd7 100644 --- a/tests/baselines/reference/library-reference-7.types +++ b/tests/baselines/reference/library-reference-7.types @@ -7,7 +7,6 @@ $.foo(); >foo : () => void === /src/node_modules/jquery/index.d.ts === - // Secondary references are possible declare var $: { foo(): void }; diff --git a/tests/baselines/reference/library-reference-8.js b/tests/baselines/reference/library-reference-8.js index a48b226cb62fc..02a7c3da83c9e 100644 --- a/tests/baselines/reference/library-reference-8.js +++ b/tests/baselines/reference/library-reference-8.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/references/library-reference-8.ts] //// //// [index.d.ts] - // Don't crash in circular library reference situations /// diff --git a/tests/baselines/reference/library-reference-8.symbols b/tests/baselines/reference/library-reference-8.symbols index a6a24689f3fcd..221f6e57c60e7 100644 --- a/tests/baselines/reference/library-reference-8.symbols +++ b/tests/baselines/reference/library-reference-8.symbols @@ -3,22 +3,21 @@ /// var x: string = alpha.a + beta.b; >x : Symbol(x, Decl(foo.ts, 2, 3)) ->alpha.a : Symbol(a, Decl(index.d.ts, 4, 20)) ->alpha : Symbol(alpha, Decl(index.d.ts, 4, 11)) ->a : Symbol(a, Decl(index.d.ts, 4, 20)) +>alpha.a : Symbol(a, Decl(index.d.ts, 3, 20)) +>alpha : Symbol(alpha, Decl(index.d.ts, 3, 11)) +>a : Symbol(a, Decl(index.d.ts, 3, 20)) >beta.b : Symbol(b, Decl(index.d.ts, 1, 19)) >beta : Symbol(beta, Decl(index.d.ts, 1, 11)) >b : Symbol(b, Decl(index.d.ts, 1, 19)) === /test/types/alpha/index.d.ts === - // Don't crash in circular library reference situations /// declare var alpha: { a: string }; ->alpha : Symbol(alpha, Decl(index.d.ts, 4, 11)) ->a : Symbol(a, Decl(index.d.ts, 4, 20)) +>alpha : Symbol(alpha, Decl(index.d.ts, 3, 11)) +>a : Symbol(a, Decl(index.d.ts, 3, 20)) === /test/types/beta/index.d.ts === /// diff --git a/tests/baselines/reference/library-reference-8.types b/tests/baselines/reference/library-reference-8.types index d8a2b6e963870..34c5186cca806 100644 --- a/tests/baselines/reference/library-reference-8.types +++ b/tests/baselines/reference/library-reference-8.types @@ -13,7 +13,6 @@ var x: string = alpha.a + beta.b; === /test/types/alpha/index.d.ts === - // Don't crash in circular library reference situations /// diff --git a/tests/baselines/reference/limitDeepInstantiations.errors.txt b/tests/baselines/reference/limitDeepInstantiations.errors.txt new file mode 100644 index 0000000000000..330e5fbc8e43e --- /dev/null +++ b/tests/baselines/reference/limitDeepInstantiations.errors.txt @@ -0,0 +1,15 @@ +tests/cases/compiler/limitDeepInstantiations.ts(3,35): error TS2550: Generic type instantiation is excessively deep and possibly infinite. +tests/cases/compiler/limitDeepInstantiations.ts(5,13): error TS2344: Type '"false"' does not satisfy the constraint '"true"'. + + +==== tests/cases/compiler/limitDeepInstantiations.ts (2 errors) ==== + // Repro from #14837 + + type Foo = { "true": Foo> }[T]; + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2550: Generic type instantiation is excessively deep and possibly infinite. + let f1: Foo<"true", {}>; + let f2: Foo<"false", {}>; + ~~~~~~~ +!!! error TS2344: Type '"false"' does not satisfy the constraint '"true"'. + \ No newline at end of file diff --git a/tests/baselines/reference/limitDeepInstantiations.js b/tests/baselines/reference/limitDeepInstantiations.js new file mode 100644 index 0000000000000..7b70cbd5956da --- /dev/null +++ b/tests/baselines/reference/limitDeepInstantiations.js @@ -0,0 +1,12 @@ +//// [limitDeepInstantiations.ts] +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +let f1: Foo<"true", {}>; +let f2: Foo<"false", {}>; + + +//// [limitDeepInstantiations.js] +// Repro from #14837 +var f1; +var f2; diff --git a/tests/baselines/reference/literalTypes1.js b/tests/baselines/reference/literalTypes1.js index cf2923e250a12..2e8c179af87bb 100644 --- a/tests/baselines/reference/literalTypes1.js +++ b/tests/baselines/reference/literalTypes1.js @@ -1,5 +1,4 @@ //// [literalTypes1.ts] - let zero: 0 = 0; let one: 1 = 1; let two: 2 = 2; diff --git a/tests/baselines/reference/literalTypes1.symbols b/tests/baselines/reference/literalTypes1.symbols index ea44ab51acc86..435cf4caf5f04 100644 --- a/tests/baselines/reference/literalTypes1.symbols +++ b/tests/baselines/reference/literalTypes1.symbols @@ -1,170 +1,169 @@ === tests/cases/conformance/types/literal/literalTypes1.ts === - let zero: 0 = 0; ->zero : Symbol(zero, Decl(literalTypes1.ts, 1, 3)) +>zero : Symbol(zero, Decl(literalTypes1.ts, 0, 3)) let one: 1 = 1; ->one : Symbol(one, Decl(literalTypes1.ts, 2, 3)) +>one : Symbol(one, Decl(literalTypes1.ts, 1, 3)) let two: 2 = 2; ->two : Symbol(two, Decl(literalTypes1.ts, 3, 3)) +>two : Symbol(two, Decl(literalTypes1.ts, 2, 3)) let oneOrTwo: 1 | 2 = <1 | 2>1; ->oneOrTwo : Symbol(oneOrTwo, Decl(literalTypes1.ts, 4, 3)) +>oneOrTwo : Symbol(oneOrTwo, Decl(literalTypes1.ts, 3, 3)) function f1(x: 0 | 1 | 2) { ->f1 : Symbol(f1, Decl(literalTypes1.ts, 4, 31)) ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>f1 : Symbol(f1, Decl(literalTypes1.ts, 3, 31)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) case zero: ->zero : Symbol(zero, Decl(literalTypes1.ts, 1, 3)) +>zero : Symbol(zero, Decl(literalTypes1.ts, 0, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) break; case one: ->one : Symbol(one, Decl(literalTypes1.ts, 2, 3)) +>one : Symbol(one, Decl(literalTypes1.ts, 1, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) break; case two: ->two : Symbol(two, Decl(literalTypes1.ts, 3, 3)) +>two : Symbol(two, Decl(literalTypes1.ts, 2, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) break; default: x; ->x : Symbol(x, Decl(literalTypes1.ts, 6, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 5, 12)) } } function f2(x: 0 | 1 | 2) { ->f2 : Symbol(f2, Decl(literalTypes1.ts, 20, 1)) ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>f2 : Symbol(f2, Decl(literalTypes1.ts, 19, 1)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) case zero: ->zero : Symbol(zero, Decl(literalTypes1.ts, 1, 3)) +>zero : Symbol(zero, Decl(literalTypes1.ts, 0, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) break; case oneOrTwo: ->oneOrTwo : Symbol(oneOrTwo, Decl(literalTypes1.ts, 4, 3)) +>oneOrTwo : Symbol(oneOrTwo, Decl(literalTypes1.ts, 3, 3)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) break; default: x; ->x : Symbol(x, Decl(literalTypes1.ts, 22, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 21, 12)) } } type Falsy = false | 0 | "" | null | undefined; ->Falsy : Symbol(Falsy, Decl(literalTypes1.ts, 33, 1)) +>Falsy : Symbol(Falsy, Decl(literalTypes1.ts, 32, 1)) function f3(x: Falsy) { ->f3 : Symbol(f3, Decl(literalTypes1.ts, 35, 47)) ->x : Symbol(x, Decl(literalTypes1.ts, 37, 12)) ->Falsy : Symbol(Falsy, Decl(literalTypes1.ts, 33, 1)) +>f3 : Symbol(f3, Decl(literalTypes1.ts, 34, 47)) +>x : Symbol(x, Decl(literalTypes1.ts, 36, 12)) +>Falsy : Symbol(Falsy, Decl(literalTypes1.ts, 32, 1)) if (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 37, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 36, 12)) x; ->x : Symbol(x, Decl(literalTypes1.ts, 37, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 36, 12)) } else { x; ->x : Symbol(x, Decl(literalTypes1.ts, 37, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 36, 12)) } } function f4(x: 0 | 1 | true | string) { ->f4 : Symbol(f4, Decl(literalTypes1.ts, 44, 1)) ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>f4 : Symbol(f4, Decl(literalTypes1.ts, 43, 1)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) case 0: x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; case 1: x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; case "abc": case "def": x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; case null: x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; case undefined: >undefined : Symbol(undefined) x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) break; default: x; ->x : Symbol(x, Decl(literalTypes1.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 45, 12)) } } function f5(x: string | number | boolean) { ->f5 : Symbol(f5, Decl(literalTypes1.ts, 67, 1)) ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>f5 : Symbol(f5, Decl(literalTypes1.ts, 66, 1)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) case "abc": x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) break; case 0: case 1: x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) break; case true: x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) break; case "hello": case 123: x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) break; default: x; ->x : Symbol(x, Decl(literalTypes1.ts, 69, 12)) +>x : Symbol(x, Decl(literalTypes1.ts, 68, 12)) } } diff --git a/tests/baselines/reference/literalTypes1.types b/tests/baselines/reference/literalTypes1.types index 1baaad3ff88cc..ed2df4ca14cfe 100644 --- a/tests/baselines/reference/literalTypes1.types +++ b/tests/baselines/reference/literalTypes1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/literalTypes1.ts === - let zero: 0 = 0; >zero : 0 >0 : 0 diff --git a/tests/baselines/reference/literalTypes3.js b/tests/baselines/reference/literalTypes3.js index 1989bb1d5a1be..46b6c6246e4d2 100644 --- a/tests/baselines/reference/literalTypes3.js +++ b/tests/baselines/reference/literalTypes3.js @@ -1,5 +1,4 @@ //// [literalTypes3.ts] - function f1(s: string) { if (s === "foo") { s; // "foo" diff --git a/tests/baselines/reference/literalTypes3.symbols b/tests/baselines/reference/literalTypes3.symbols index 6cc7ab007e680..85838498df107 100644 --- a/tests/baselines/reference/literalTypes3.symbols +++ b/tests/baselines/reference/literalTypes3.symbols @@ -1,137 +1,136 @@ === tests/cases/conformance/types/literal/literalTypes3.ts === - function f1(s: string) { >f1 : Symbol(f1, Decl(literalTypes3.ts, 0, 0)) ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) if (s === "foo") { ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) s; // "foo" ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) } if (s === "foo" || s === "bar") { ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) s; // "foo" | "bar" ->s : Symbol(s, Decl(literalTypes3.ts, 1, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 0, 12)) } } function f2(s: string) { ->f2 : Symbol(f2, Decl(literalTypes3.ts, 8, 1)) ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>f2 : Symbol(f2, Decl(literalTypes3.ts, 7, 1)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) switch (s) { ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) case "foo": case "bar": s; // "foo" | "bar" ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) case "baz": s; // "foo" | "bar" | "baz" ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) break; default: s; // string ->s : Symbol(s, Decl(literalTypes3.ts, 10, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 9, 12)) } } function f3(s: string) { ->f3 : Symbol(f3, Decl(literalTypes3.ts, 21, 1)) ->s : Symbol(s, Decl(literalTypes3.ts, 23, 12)) +>f3 : Symbol(f3, Decl(literalTypes3.ts, 20, 1)) +>s : Symbol(s, Decl(literalTypes3.ts, 22, 12)) return s === "foo" || s === "bar" ? s : undefined; // "foo" | "bar" | undefined ->s : Symbol(s, Decl(literalTypes3.ts, 23, 12)) ->s : Symbol(s, Decl(literalTypes3.ts, 23, 12)) ->s : Symbol(s, Decl(literalTypes3.ts, 23, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 22, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 22, 12)) +>s : Symbol(s, Decl(literalTypes3.ts, 22, 12)) >undefined : Symbol(undefined) } function f4(x: number) { ->f4 : Symbol(f4, Decl(literalTypes3.ts, 25, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 27, 12)) +>f4 : Symbol(f4, Decl(literalTypes3.ts, 24, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 26, 12)) if (x === 1 || x === 2) { ->x : Symbol(x, Decl(literalTypes3.ts, 27, 12)) ->x : Symbol(x, Decl(literalTypes3.ts, 27, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 26, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 26, 12)) return x; // 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 27, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 26, 12)) } throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function f5(x: number, y: 1 | 2) { ->f5 : Symbol(f5, Decl(literalTypes3.ts, 32, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 34, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 34, 22)) +>f5 : Symbol(f5, Decl(literalTypes3.ts, 31, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 33, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 33, 22)) if (x === 0 || x === y) { ->x : Symbol(x, Decl(literalTypes3.ts, 34, 12)) ->x : Symbol(x, Decl(literalTypes3.ts, 34, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 34, 22)) +>x : Symbol(x, Decl(literalTypes3.ts, 33, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 33, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 33, 22)) x; // 0 | 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 34, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 33, 12)) } } function f6(x: number, y: 1 | 2) { ->f6 : Symbol(f6, Decl(literalTypes3.ts, 38, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 40, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 40, 22)) +>f6 : Symbol(f6, Decl(literalTypes3.ts, 37, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 39, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 39, 22)) if (y === x || 0 === x) { ->y : Symbol(y, Decl(literalTypes3.ts, 40, 22)) ->x : Symbol(x, Decl(literalTypes3.ts, 40, 12)) ->x : Symbol(x, Decl(literalTypes3.ts, 40, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 39, 22)) +>x : Symbol(x, Decl(literalTypes3.ts, 39, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 39, 12)) x; // 0 | 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 40, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 39, 12)) } } function f7(x: number | "foo" | "bar", y: 1 | 2 | string) { ->f7 : Symbol(f7, Decl(literalTypes3.ts, 44, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 46, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 46, 38)) +>f7 : Symbol(f7, Decl(literalTypes3.ts, 43, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 45, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 45, 38)) if (x === y) { ->x : Symbol(x, Decl(literalTypes3.ts, 46, 12)) ->y : Symbol(y, Decl(literalTypes3.ts, 46, 38)) +>x : Symbol(x, Decl(literalTypes3.ts, 45, 12)) +>y : Symbol(y, Decl(literalTypes3.ts, 45, 38)) x; // "foo" | "bar" | 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 46, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 45, 12)) } } function f8(x: number | "foo" | "bar") { ->f8 : Symbol(f8, Decl(literalTypes3.ts, 50, 1)) ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>f8 : Symbol(f8, Decl(literalTypes3.ts, 49, 1)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) switch (x) { ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) case 1: case 2: x; // 1 | 2 ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) break; case "foo": x; // "foo" ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) break; default: x; // number | "bar" ->x : Symbol(x, Decl(literalTypes3.ts, 52, 12)) +>x : Symbol(x, Decl(literalTypes3.ts, 51, 12)) } } diff --git a/tests/baselines/reference/literalTypes3.types b/tests/baselines/reference/literalTypes3.types index 6161bc4b72a6f..059e2777e541e 100644 --- a/tests/baselines/reference/literalTypes3.types +++ b/tests/baselines/reference/literalTypes3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/literalTypes3.ts === - function f1(s: string) { >f1 : (s: string) => void >s : string diff --git a/tests/baselines/reference/literals.errors.txt b/tests/baselines/reference/literals.errors.txt index ae058e0b530b1..426e832c62227 100644 --- a/tests/baselines/reference/literals.errors.txt +++ b/tests/baselines/reference/literals.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/expressions/literals/literals.ts(9,10): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/literals/literals.ts(9,17): error TS2531: Object is possibly 'null'. -tests/cases/conformance/expressions/literals/literals.ts(10,9): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/literals/literals.ts(10,21): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/expressions/literals/literals.ts(20,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o1'. -tests/cases/conformance/expressions/literals/literals.ts(25,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'. +tests/cases/conformance/expressions/literals/literals.ts(8,10): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/literals/literals.ts(8,17): error TS2531: Object is possibly 'null'. +tests/cases/conformance/expressions/literals/literals.ts(9,9): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/literals/literals.ts(9,21): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/expressions/literals/literals.ts(19,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o1'. +tests/cases/conformance/expressions/literals/literals.ts(24,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'. ==== tests/cases/conformance/expressions/literals/literals.ts (6 errors) ==== - //typeof null is Null //typeof true is Boolean //typeof false is Boolean diff --git a/tests/baselines/reference/literals.js b/tests/baselines/reference/literals.js index b92e11c13ce99..9f8d8f56be925 100644 --- a/tests/baselines/reference/literals.js +++ b/tests/baselines/reference/literals.js @@ -1,5 +1,4 @@ //// [literals.ts] - //typeof null is Null //typeof true is Boolean //typeof false is Boolean diff --git a/tests/baselines/reference/literalsInComputedProperties1.errors.txt b/tests/baselines/reference/literalsInComputedProperties1.errors.txt index e9972229f795f..0a0412721db4f 100644 --- a/tests/baselines/reference/literalsInComputedProperties1.errors.txt +++ b/tests/baselines/reference/literalsInComputedProperties1.errors.txt @@ -1,11 +1,10 @@ +tests/cases/compiler/literalsInComputedProperties1.ts(39,5): error TS2452: An enum member cannot have a numeric name. tests/cases/compiler/literalsInComputedProperties1.ts(40,5): error TS2452: An enum member cannot have a numeric name. tests/cases/compiler/literalsInComputedProperties1.ts(41,5): error TS2452: An enum member cannot have a numeric name. tests/cases/compiler/literalsInComputedProperties1.ts(42,5): error TS2452: An enum member cannot have a numeric name. -tests/cases/compiler/literalsInComputedProperties1.ts(43,5): error TS2452: An enum member cannot have a numeric name. ==== tests/cases/compiler/literalsInComputedProperties1.ts (4 errors) ==== - let x = { 1:1, [2]:1, diff --git a/tests/baselines/reference/literalsInComputedProperties1.js b/tests/baselines/reference/literalsInComputedProperties1.js index 77eb70c2396b1..dd94709d2cf72 100644 --- a/tests/baselines/reference/literalsInComputedProperties1.js +++ b/tests/baselines/reference/literalsInComputedProperties1.js @@ -1,5 +1,4 @@ //// [literalsInComputedProperties1.ts] - let x = { 1:1, [2]:1, diff --git a/tests/baselines/reference/localClassesInLoop_ES6.js b/tests/baselines/reference/localClassesInLoop_ES6.js index b9e7dccff1f71..61c129443576c 100644 --- a/tests/baselines/reference/localClassesInLoop_ES6.js +++ b/tests/baselines/reference/localClassesInLoop_ES6.js @@ -1,5 +1,4 @@ //// [localClassesInLoop_ES6.ts] - declare function use(a: any); "use strict" diff --git a/tests/baselines/reference/localClassesInLoop_ES6.symbols b/tests/baselines/reference/localClassesInLoop_ES6.symbols index f70373a4d73ed..582eca51f041a 100644 --- a/tests/baselines/reference/localClassesInLoop_ES6.symbols +++ b/tests/baselines/reference/localClassesInLoop_ES6.symbols @@ -1,30 +1,29 @@ === tests/cases/compiler/localClassesInLoop_ES6.ts === - declare function use(a: any); >use : Symbol(use, Decl(localClassesInLoop_ES6.ts, 0, 0)) ->a : Symbol(a, Decl(localClassesInLoop_ES6.ts, 1, 21)) +>a : Symbol(a, Decl(localClassesInLoop_ES6.ts, 0, 21)) "use strict" var data = []; ->data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 4, 3)) +>data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 3, 3)) for (let x = 0; x < 2; ++x) { ->x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 5, 8)) ->x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 5, 8)) ->x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 5, 8)) +>x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 4, 8)) +>x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 4, 8)) +>x : Symbol(x, Decl(localClassesInLoop_ES6.ts, 4, 8)) class C { } ->C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 5, 29)) +>C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 4, 29)) data.push(() => C); >data.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 4, 3)) +>data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 3, 3)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 5, 29)) +>C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 4, 29)) } use(data[0]() === data[1]()); >use : Symbol(use, Decl(localClassesInLoop_ES6.ts, 0, 0)) ->data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 4, 3)) ->data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 4, 3)) +>data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 3, 3)) +>data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 3, 3)) diff --git a/tests/baselines/reference/localClassesInLoop_ES6.types b/tests/baselines/reference/localClassesInLoop_ES6.types index 9d487f6c60051..971a127da4058 100644 --- a/tests/baselines/reference/localClassesInLoop_ES6.types +++ b/tests/baselines/reference/localClassesInLoop_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/localClassesInLoop_ES6.ts === - declare function use(a: any); >use : (a: any) => any >a : any diff --git a/tests/baselines/reference/localRequireFunction.js b/tests/baselines/reference/localRequireFunction.js index 1ae20821a0741..8f8fe2d40d847 100644 --- a/tests/baselines/reference/localRequireFunction.js +++ b/tests/baselines/reference/localRequireFunction.js @@ -1,5 +1,4 @@ //// [app.js] - function require(a) { return a; } diff --git a/tests/baselines/reference/localRequireFunction.symbols b/tests/baselines/reference/localRequireFunction.symbols index b977328f0efb2..d8fbf23276ad9 100644 --- a/tests/baselines/reference/localRequireFunction.symbols +++ b/tests/baselines/reference/localRequireFunction.symbols @@ -1,18 +1,17 @@ === tests/cases/compiler/app.js === - function require(a) { >require : Symbol(require, Decl(app.js, 0, 0)) ->a : Symbol(a, Decl(app.js, 1, 17)) +>a : Symbol(a, Decl(app.js, 0, 17)) return a; ->a : Symbol(a, Decl(app.js, 1, 17)) +>a : Symbol(a, Decl(app.js, 0, 17)) } const fs = require("fs"); ->fs : Symbol(fs, Decl(app.js, 5, 5)) +>fs : Symbol(fs, Decl(app.js, 4, 5)) >require : Symbol(require, Decl(app.js, 0, 0)) const text = fs.readFileSync("/a/b/c"); ->text : Symbol(text, Decl(app.js, 6, 5)) ->fs : Symbol(fs, Decl(app.js, 5, 5)) +>text : Symbol(text, Decl(app.js, 5, 5)) +>fs : Symbol(fs, Decl(app.js, 4, 5)) diff --git a/tests/baselines/reference/localRequireFunction.types b/tests/baselines/reference/localRequireFunction.types index 4b5c7578cd976..21f9c81bd29d2 100644 --- a/tests/baselines/reference/localRequireFunction.types +++ b/tests/baselines/reference/localRequireFunction.types @@ -1,5 +1,4 @@ === tests/cases/compiler/app.js === - function require(a) { >require : (a: any) => any >a : any diff --git a/tests/baselines/reference/localTypes1.js b/tests/baselines/reference/localTypes1.js index d356bd58e201e..ab12be6d9fce5 100644 --- a/tests/baselines/reference/localTypes1.js +++ b/tests/baselines/reference/localTypes1.js @@ -1,5 +1,4 @@ //// [localTypes1.ts] - function f1() { enum E { A, B, C diff --git a/tests/baselines/reference/localTypes1.symbols b/tests/baselines/reference/localTypes1.symbols index 3ee47086b269d..528826a1d1b22 100644 --- a/tests/baselines/reference/localTypes1.symbols +++ b/tests/baselines/reference/localTypes1.symbols @@ -1,357 +1,356 @@ === tests/cases/conformance/types/localTypes/localTypes1.ts === - function f1() { >f1 : Symbol(f1, Decl(localTypes1.ts, 0, 0)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 1, 15)) +>E : Symbol(E, Decl(localTypes1.ts, 0, 15)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 2, 12)) ->B : Symbol(E.B, Decl(localTypes1.ts, 3, 10)) ->C : Symbol(E.C, Decl(localTypes1.ts, 3, 13)) +>A : Symbol(E.A, Decl(localTypes1.ts, 1, 12)) +>B : Symbol(E.B, Decl(localTypes1.ts, 2, 10)) +>C : Symbol(E.C, Decl(localTypes1.ts, 2, 13)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 4, 5)) +>C : Symbol(C, Decl(localTypes1.ts, 3, 5)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 5, 13)) ->E : Symbol(E, Decl(localTypes1.ts, 1, 15)) +>x : Symbol(C.x, Decl(localTypes1.ts, 4, 13)) +>E : Symbol(E, Decl(localTypes1.ts, 0, 15)) } interface I { ->I : Symbol(I, Decl(localTypes1.ts, 7, 5)) +>I : Symbol(I, Decl(localTypes1.ts, 6, 5)) x: E; ->x : Symbol(I.x, Decl(localTypes1.ts, 8, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 1, 15)) +>x : Symbol(I.x, Decl(localTypes1.ts, 7, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 0, 15)) } type A = I[]; ->A : Symbol(A, Decl(localTypes1.ts, 10, 5)) ->I : Symbol(I, Decl(localTypes1.ts, 7, 5)) +>A : Symbol(A, Decl(localTypes1.ts, 9, 5)) +>I : Symbol(I, Decl(localTypes1.ts, 6, 5)) let a: A = [new C()]; ->a : Symbol(a, Decl(localTypes1.ts, 12, 7)) ->A : Symbol(A, Decl(localTypes1.ts, 10, 5)) ->C : Symbol(C, Decl(localTypes1.ts, 4, 5)) +>a : Symbol(a, Decl(localTypes1.ts, 11, 7)) +>A : Symbol(A, Decl(localTypes1.ts, 9, 5)) +>C : Symbol(C, Decl(localTypes1.ts, 3, 5)) a[0].x = E.B; ->a[0].x : Symbol(I.x, Decl(localTypes1.ts, 8, 17)) ->a : Symbol(a, Decl(localTypes1.ts, 12, 7)) ->x : Symbol(I.x, Decl(localTypes1.ts, 8, 17)) ->E.B : Symbol(E.B, Decl(localTypes1.ts, 3, 10)) ->E : Symbol(E, Decl(localTypes1.ts, 1, 15)) ->B : Symbol(E.B, Decl(localTypes1.ts, 3, 10)) +>a[0].x : Symbol(I.x, Decl(localTypes1.ts, 7, 17)) +>a : Symbol(a, Decl(localTypes1.ts, 11, 7)) +>x : Symbol(I.x, Decl(localTypes1.ts, 7, 17)) +>E.B : Symbol(E.B, Decl(localTypes1.ts, 2, 10)) +>E : Symbol(E, Decl(localTypes1.ts, 0, 15)) +>B : Symbol(E.B, Decl(localTypes1.ts, 2, 10)) return a; ->a : Symbol(a, Decl(localTypes1.ts, 12, 7)) +>a : Symbol(a, Decl(localTypes1.ts, 11, 7)) } function f2() { ->f2 : Symbol(f2, Decl(localTypes1.ts, 15, 1)) +>f2 : Symbol(f2, Decl(localTypes1.ts, 14, 1)) function g() { ->g : Symbol(g, Decl(localTypes1.ts, 17, 15)) +>g : Symbol(g, Decl(localTypes1.ts, 16, 15)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 18, 18)) +>E : Symbol(E, Decl(localTypes1.ts, 17, 18)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 19, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 20, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 20, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 18, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 19, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 19, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 21, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 20, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 22, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 18, 18)) +>x : Symbol(C.x, Decl(localTypes1.ts, 21, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 17, 18)) } interface I { ->I : Symbol(I, Decl(localTypes1.ts, 24, 9)) +>I : Symbol(I, Decl(localTypes1.ts, 23, 9)) x: E; ->x : Symbol(I.x, Decl(localTypes1.ts, 25, 21)) ->E : Symbol(E, Decl(localTypes1.ts, 18, 18)) +>x : Symbol(I.x, Decl(localTypes1.ts, 24, 21)) +>E : Symbol(E, Decl(localTypes1.ts, 17, 18)) } type A = I[]; ->A : Symbol(A, Decl(localTypes1.ts, 27, 9)) ->I : Symbol(I, Decl(localTypes1.ts, 24, 9)) +>A : Symbol(A, Decl(localTypes1.ts, 26, 9)) +>I : Symbol(I, Decl(localTypes1.ts, 23, 9)) let a: A = [new C()]; ->a : Symbol(a, Decl(localTypes1.ts, 29, 11)) ->A : Symbol(A, Decl(localTypes1.ts, 27, 9)) ->C : Symbol(C, Decl(localTypes1.ts, 21, 9)) +>a : Symbol(a, Decl(localTypes1.ts, 28, 11)) +>A : Symbol(A, Decl(localTypes1.ts, 26, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 20, 9)) a[0].x = E.B; ->a[0].x : Symbol(I.x, Decl(localTypes1.ts, 25, 21)) ->a : Symbol(a, Decl(localTypes1.ts, 29, 11)) ->x : Symbol(I.x, Decl(localTypes1.ts, 25, 21)) ->E.B : Symbol(E.B, Decl(localTypes1.ts, 20, 14)) ->E : Symbol(E, Decl(localTypes1.ts, 18, 18)) ->B : Symbol(E.B, Decl(localTypes1.ts, 20, 14)) +>a[0].x : Symbol(I.x, Decl(localTypes1.ts, 24, 21)) +>a : Symbol(a, Decl(localTypes1.ts, 28, 11)) +>x : Symbol(I.x, Decl(localTypes1.ts, 24, 21)) +>E.B : Symbol(E.B, Decl(localTypes1.ts, 19, 14)) +>E : Symbol(E, Decl(localTypes1.ts, 17, 18)) +>B : Symbol(E.B, Decl(localTypes1.ts, 19, 14)) return a; ->a : Symbol(a, Decl(localTypes1.ts, 29, 11)) +>a : Symbol(a, Decl(localTypes1.ts, 28, 11)) } return g(); ->g : Symbol(g, Decl(localTypes1.ts, 17, 15)) +>g : Symbol(g, Decl(localTypes1.ts, 16, 15)) } function f3(b: boolean) { ->f3 : Symbol(f3, Decl(localTypes1.ts, 34, 1)) ->b : Symbol(b, Decl(localTypes1.ts, 36, 12)) +>f3 : Symbol(f3, Decl(localTypes1.ts, 33, 1)) +>b : Symbol(b, Decl(localTypes1.ts, 35, 12)) if (true) { enum E { ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 38, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 39, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 37, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 38, 17)) } if (b) { ->b : Symbol(b, Decl(localTypes1.ts, 36, 12)) +>b : Symbol(b, Decl(localTypes1.ts, 35, 12)) class C { ->C : Symbol(C, Decl(localTypes1.ts, 41, 16)) +>C : Symbol(C, Decl(localTypes1.ts, 40, 16)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 42, 21)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>x : Symbol(C.x, Decl(localTypes1.ts, 41, 21)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) } interface I { ->I : Symbol(I, Decl(localTypes1.ts, 44, 13)) +>I : Symbol(I, Decl(localTypes1.ts, 43, 13)) x: E; ->x : Symbol(I.x, Decl(localTypes1.ts, 45, 25)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>x : Symbol(I.x, Decl(localTypes1.ts, 44, 25)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) } type A = I[]; ->A : Symbol(A, Decl(localTypes1.ts, 47, 13)) ->I : Symbol(I, Decl(localTypes1.ts, 44, 13)) +>A : Symbol(A, Decl(localTypes1.ts, 46, 13)) +>I : Symbol(I, Decl(localTypes1.ts, 43, 13)) let a: A = [new C()]; ->a : Symbol(a, Decl(localTypes1.ts, 49, 15)) ->A : Symbol(A, Decl(localTypes1.ts, 47, 13)) ->C : Symbol(C, Decl(localTypes1.ts, 41, 16)) +>a : Symbol(a, Decl(localTypes1.ts, 48, 15)) +>A : Symbol(A, Decl(localTypes1.ts, 46, 13)) +>C : Symbol(C, Decl(localTypes1.ts, 40, 16)) a[0].x = E.B; ->a[0].x : Symbol(I.x, Decl(localTypes1.ts, 45, 25)) ->a : Symbol(a, Decl(localTypes1.ts, 49, 15)) ->x : Symbol(I.x, Decl(localTypes1.ts, 45, 25)) ->E.B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) ->B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) +>a[0].x : Symbol(I.x, Decl(localTypes1.ts, 44, 25)) +>a : Symbol(a, Decl(localTypes1.ts, 48, 15)) +>x : Symbol(I.x, Decl(localTypes1.ts, 44, 25)) +>E.B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) +>B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) return a; ->a : Symbol(a, Decl(localTypes1.ts, 49, 15)) +>a : Symbol(a, Decl(localTypes1.ts, 48, 15)) } else { class A { ->A : Symbol(A, Decl(localTypes1.ts, 53, 14)) +>A : Symbol(A, Decl(localTypes1.ts, 52, 14)) x: E; ->x : Symbol(A.x, Decl(localTypes1.ts, 54, 21)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>x : Symbol(A.x, Decl(localTypes1.ts, 53, 21)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) } interface J { ->J : Symbol(J, Decl(localTypes1.ts, 56, 13)) +>J : Symbol(J, Decl(localTypes1.ts, 55, 13)) x: E; ->x : Symbol(J.x, Decl(localTypes1.ts, 57, 25)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) +>x : Symbol(J.x, Decl(localTypes1.ts, 56, 25)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) } type C = J[]; ->C : Symbol(C, Decl(localTypes1.ts, 59, 13)) ->J : Symbol(J, Decl(localTypes1.ts, 56, 13)) +>C : Symbol(C, Decl(localTypes1.ts, 58, 13)) +>J : Symbol(J, Decl(localTypes1.ts, 55, 13)) let c: C = [new A()]; ->c : Symbol(c, Decl(localTypes1.ts, 61, 15)) ->C : Symbol(C, Decl(localTypes1.ts, 59, 13)) ->A : Symbol(A, Decl(localTypes1.ts, 53, 14)) +>c : Symbol(c, Decl(localTypes1.ts, 60, 15)) +>C : Symbol(C, Decl(localTypes1.ts, 58, 13)) +>A : Symbol(A, Decl(localTypes1.ts, 52, 14)) c[0].x = E.B; ->c[0].x : Symbol(J.x, Decl(localTypes1.ts, 57, 25)) ->c : Symbol(c, Decl(localTypes1.ts, 61, 15)) ->x : Symbol(J.x, Decl(localTypes1.ts, 57, 25)) ->E.B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) ->E : Symbol(E, Decl(localTypes1.ts, 37, 15)) ->B : Symbol(E.B, Decl(localTypes1.ts, 39, 14)) +>c[0].x : Symbol(J.x, Decl(localTypes1.ts, 56, 25)) +>c : Symbol(c, Decl(localTypes1.ts, 60, 15)) +>x : Symbol(J.x, Decl(localTypes1.ts, 56, 25)) +>E.B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) +>E : Symbol(E, Decl(localTypes1.ts, 36, 15)) +>B : Symbol(E.B, Decl(localTypes1.ts, 38, 14)) return c; ->c : Symbol(c, Decl(localTypes1.ts, 61, 15)) +>c : Symbol(c, Decl(localTypes1.ts, 60, 15)) } } } function f5() { ->f5 : Symbol(f5, Decl(localTypes1.ts, 66, 1)) +>f5 : Symbol(f5, Decl(localTypes1.ts, 65, 1)) var z1 = function () { ->z1 : Symbol(z1, Decl(localTypes1.ts, 69, 7)) +>z1 : Symbol(z1, Decl(localTypes1.ts, 68, 7)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 69, 26)) +>E : Symbol(E, Decl(localTypes1.ts, 68, 26)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 70, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 71, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 71, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 69, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 70, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 70, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 72, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 71, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 73, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 69, 26)) +>x : Symbol(C.x, Decl(localTypes1.ts, 72, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 68, 26)) } return new C(); ->C : Symbol(C, Decl(localTypes1.ts, 72, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 71, 9)) } var z2 = () => { ->z2 : Symbol(z2, Decl(localTypes1.ts, 78, 7)) +>z2 : Symbol(z2, Decl(localTypes1.ts, 77, 7)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 78, 20)) +>E : Symbol(E, Decl(localTypes1.ts, 77, 20)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 79, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 80, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 80, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 78, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 79, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 79, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 81, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 80, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 82, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 78, 20)) +>x : Symbol(C.x, Decl(localTypes1.ts, 81, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 77, 20)) } return new C(); ->C : Symbol(C, Decl(localTypes1.ts, 81, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 80, 9)) } } class A { ->A : Symbol(A, Decl(localTypes1.ts, 87, 1)) +>A : Symbol(A, Decl(localTypes1.ts, 86, 1)) constructor() { enum E { ->E : Symbol(E, Decl(localTypes1.ts, 90, 19)) +>E : Symbol(E, Decl(localTypes1.ts, 89, 19)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 91, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 92, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 92, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 90, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 91, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 91, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 93, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 92, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 94, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 90, 19)) +>x : Symbol(C.x, Decl(localTypes1.ts, 93, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 89, 19)) } } m() { ->m : Symbol(A.m, Decl(localTypes1.ts, 97, 5)) +>m : Symbol(A.m, Decl(localTypes1.ts, 96, 5)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 98, 9)) +>E : Symbol(E, Decl(localTypes1.ts, 97, 9)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 99, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 100, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 100, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 98, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 99, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 99, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 101, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 100, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 102, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 98, 9)) +>x : Symbol(C.x, Decl(localTypes1.ts, 101, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 97, 9)) } return new C(); ->C : Symbol(C, Decl(localTypes1.ts, 101, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 100, 9)) } get p() { ->p : Symbol(A.p, Decl(localTypes1.ts, 106, 5)) +>p : Symbol(A.p, Decl(localTypes1.ts, 105, 5)) enum E { ->E : Symbol(E, Decl(localTypes1.ts, 107, 13)) +>E : Symbol(E, Decl(localTypes1.ts, 106, 13)) A, B, C ->A : Symbol(E.A, Decl(localTypes1.ts, 108, 16)) ->B : Symbol(E.B, Decl(localTypes1.ts, 109, 14)) ->C : Symbol(E.C, Decl(localTypes1.ts, 109, 17)) +>A : Symbol(E.A, Decl(localTypes1.ts, 107, 16)) +>B : Symbol(E.B, Decl(localTypes1.ts, 108, 14)) +>C : Symbol(E.C, Decl(localTypes1.ts, 108, 17)) } class C { ->C : Symbol(C, Decl(localTypes1.ts, 110, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 109, 9)) x: E; ->x : Symbol(C.x, Decl(localTypes1.ts, 111, 17)) ->E : Symbol(E, Decl(localTypes1.ts, 107, 13)) +>x : Symbol(C.x, Decl(localTypes1.ts, 110, 17)) +>E : Symbol(E, Decl(localTypes1.ts, 106, 13)) } return new C(); ->C : Symbol(C, Decl(localTypes1.ts, 110, 9)) +>C : Symbol(C, Decl(localTypes1.ts, 109, 9)) } } function f6() { ->f6 : Symbol(f6, Decl(localTypes1.ts, 116, 1)) +>f6 : Symbol(f6, Decl(localTypes1.ts, 115, 1)) class A { ->A : Symbol(A, Decl(localTypes1.ts, 118, 15)) +>A : Symbol(A, Decl(localTypes1.ts, 117, 15)) a: string; ->a : Symbol(A.a, Decl(localTypes1.ts, 119, 13)) +>a : Symbol(A.a, Decl(localTypes1.ts, 118, 13)) } function g() { ->g : Symbol(g, Decl(localTypes1.ts, 121, 5)) +>g : Symbol(g, Decl(localTypes1.ts, 120, 5)) class B extends A { ->B : Symbol(B, Decl(localTypes1.ts, 122, 18)) ->A : Symbol(A, Decl(localTypes1.ts, 118, 15)) +>B : Symbol(B, Decl(localTypes1.ts, 121, 18)) +>A : Symbol(A, Decl(localTypes1.ts, 117, 15)) b: string; ->b : Symbol(B.b, Decl(localTypes1.ts, 123, 27)) +>b : Symbol(B.b, Decl(localTypes1.ts, 122, 27)) } function h() { ->h : Symbol(h, Decl(localTypes1.ts, 125, 9)) +>h : Symbol(h, Decl(localTypes1.ts, 124, 9)) class C extends B { ->C : Symbol(C, Decl(localTypes1.ts, 126, 22)) ->B : Symbol(B, Decl(localTypes1.ts, 122, 18)) +>C : Symbol(C, Decl(localTypes1.ts, 125, 22)) +>B : Symbol(B, Decl(localTypes1.ts, 121, 18)) c: string; ->c : Symbol(C.c, Decl(localTypes1.ts, 127, 31)) +>c : Symbol(C.c, Decl(localTypes1.ts, 126, 31)) } var x = new C(); ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) ->C : Symbol(C, Decl(localTypes1.ts, 126, 22)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) +>C : Symbol(C, Decl(localTypes1.ts, 125, 22)) x.a = "a"; ->x.a : Symbol(A.a, Decl(localTypes1.ts, 119, 13)) ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) ->a : Symbol(A.a, Decl(localTypes1.ts, 119, 13)) +>x.a : Symbol(A.a, Decl(localTypes1.ts, 118, 13)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) +>a : Symbol(A.a, Decl(localTypes1.ts, 118, 13)) x.b = "b"; ->x.b : Symbol(B.b, Decl(localTypes1.ts, 123, 27)) ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) ->b : Symbol(B.b, Decl(localTypes1.ts, 123, 27)) +>x.b : Symbol(B.b, Decl(localTypes1.ts, 122, 27)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) +>b : Symbol(B.b, Decl(localTypes1.ts, 122, 27)) x.c = "c"; ->x.c : Symbol(C.c, Decl(localTypes1.ts, 127, 31)) ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) ->c : Symbol(C.c, Decl(localTypes1.ts, 127, 31)) +>x.c : Symbol(C.c, Decl(localTypes1.ts, 126, 31)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) +>c : Symbol(C.c, Decl(localTypes1.ts, 126, 31)) return x; ->x : Symbol(x, Decl(localTypes1.ts, 130, 15)) +>x : Symbol(x, Decl(localTypes1.ts, 129, 15)) } return h(); ->h : Symbol(h, Decl(localTypes1.ts, 125, 9)) +>h : Symbol(h, Decl(localTypes1.ts, 124, 9)) } return g(); ->g : Symbol(g, Decl(localTypes1.ts, 121, 5)) +>g : Symbol(g, Decl(localTypes1.ts, 120, 5)) } diff --git a/tests/baselines/reference/localTypes1.types b/tests/baselines/reference/localTypes1.types index 7ac6896b9f351..73d9bde168e80 100644 --- a/tests/baselines/reference/localTypes1.types +++ b/tests/baselines/reference/localTypes1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/localTypes/localTypes1.ts === - function f1() { >f1 : () => I[] diff --git a/tests/baselines/reference/localTypes4.errors.txt b/tests/baselines/reference/localTypes4.errors.txt index 4d08644ea89c8..cad9d30c933b0 100644 --- a/tests/baselines/reference/localTypes4.errors.txt +++ b/tests/baselines/reference/localTypes4.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/types/localTypes/localTypes4.ts(11,19): error TS2304: Cannot find name 'T'. -tests/cases/conformance/types/localTypes/localTypes4.ts(11,23): error TS2304: Cannot find name 'T'. -tests/cases/conformance/types/localTypes/localTypes4.ts(19,16): error TS2300: Duplicate identifier 'T'. -tests/cases/conformance/types/localTypes/localTypes4.ts(20,19): error TS2300: Duplicate identifier 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(10,19): error TS2304: Cannot find name 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(10,23): error TS2304: Cannot find name 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(18,16): error TS2300: Duplicate identifier 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(19,19): error TS2300: Duplicate identifier 'T'. ==== tests/cases/conformance/types/localTypes/localTypes4.ts (4 errors) ==== - function f1() { // Type parameters are in scope in parameters and return types function f(x: T): T { diff --git a/tests/baselines/reference/localTypes4.js b/tests/baselines/reference/localTypes4.js index 3b81175d2b620..8f51761a65af6 100644 --- a/tests/baselines/reference/localTypes4.js +++ b/tests/baselines/reference/localTypes4.js @@ -1,5 +1,4 @@ //// [localTypes4.ts] - function f1() { // Type parameters are in scope in parameters and return types function f(x: T): T { diff --git a/tests/baselines/reference/logicalAndOperatorStrictMode.js b/tests/baselines/reference/logicalAndOperatorStrictMode.js index ecb5bc1642908..5dd95f2cdb666 100644 --- a/tests/baselines/reference/logicalAndOperatorStrictMode.js +++ b/tests/baselines/reference/logicalAndOperatorStrictMode.js @@ -1,5 +1,4 @@ //// [logicalAndOperatorStrictMode.ts] - const a = [0]; const s = ""; const x = 0; diff --git a/tests/baselines/reference/logicalAndOperatorStrictMode.symbols b/tests/baselines/reference/logicalAndOperatorStrictMode.symbols index e3425a261492b..1da489b66395a 100644 --- a/tests/baselines/reference/logicalAndOperatorStrictMode.symbols +++ b/tests/baselines/reference/logicalAndOperatorStrictMode.symbols @@ -1,351 +1,350 @@ === tests/cases/conformance/expressions/binaryOperators/logicalAndOperator/logicalAndOperatorStrictMode.ts === - const a = [0]; ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const s = ""; ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const x = 0; ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const b = false; ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const v: void = undefined; ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) >undefined : Symbol(undefined) const u = undefined; ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) >undefined : Symbol(undefined) const n = null; ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const z = s || x || u; ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const a1 = a && a; ->a1 : Symbol(a1, Decl(logicalAndOperatorStrictMode.ts, 10, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>a1 : Symbol(a1, Decl(logicalAndOperatorStrictMode.ts, 9, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const a2 = a && s; ->a2 : Symbol(a2, Decl(logicalAndOperatorStrictMode.ts, 11, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>a2 : Symbol(a2, Decl(logicalAndOperatorStrictMode.ts, 10, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const a3 = a && x; ->a3 : Symbol(a3, Decl(logicalAndOperatorStrictMode.ts, 12, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>a3 : Symbol(a3, Decl(logicalAndOperatorStrictMode.ts, 11, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const a4 = a && b; ->a4 : Symbol(a4, Decl(logicalAndOperatorStrictMode.ts, 13, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>a4 : Symbol(a4, Decl(logicalAndOperatorStrictMode.ts, 12, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const a5 = a && v; ->a5 : Symbol(a5, Decl(logicalAndOperatorStrictMode.ts, 14, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>a5 : Symbol(a5, Decl(logicalAndOperatorStrictMode.ts, 13, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const a6 = a && u; ->a6 : Symbol(a6, Decl(logicalAndOperatorStrictMode.ts, 15, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>a6 : Symbol(a6, Decl(logicalAndOperatorStrictMode.ts, 14, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const a7 = a && n; ->a7 : Symbol(a7, Decl(logicalAndOperatorStrictMode.ts, 16, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>a7 : Symbol(a7, Decl(logicalAndOperatorStrictMode.ts, 15, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const a8 = a && z; ->a8 : Symbol(a8, Decl(logicalAndOperatorStrictMode.ts, 17, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>a8 : Symbol(a8, Decl(logicalAndOperatorStrictMode.ts, 16, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const s1 = s && a; ->s1 : Symbol(s1, Decl(logicalAndOperatorStrictMode.ts, 19, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>s1 : Symbol(s1, Decl(logicalAndOperatorStrictMode.ts, 18, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const s2 = s && s; ->s2 : Symbol(s2, Decl(logicalAndOperatorStrictMode.ts, 20, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>s2 : Symbol(s2, Decl(logicalAndOperatorStrictMode.ts, 19, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const s3 = s && x; ->s3 : Symbol(s3, Decl(logicalAndOperatorStrictMode.ts, 21, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>s3 : Symbol(s3, Decl(logicalAndOperatorStrictMode.ts, 20, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const s4 = s && b; ->s4 : Symbol(s4, Decl(logicalAndOperatorStrictMode.ts, 22, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>s4 : Symbol(s4, Decl(logicalAndOperatorStrictMode.ts, 21, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const s5 = s && v; ->s5 : Symbol(s5, Decl(logicalAndOperatorStrictMode.ts, 23, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>s5 : Symbol(s5, Decl(logicalAndOperatorStrictMode.ts, 22, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const s6 = s && u; ->s6 : Symbol(s6, Decl(logicalAndOperatorStrictMode.ts, 24, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>s6 : Symbol(s6, Decl(logicalAndOperatorStrictMode.ts, 23, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const s7 = s && n; ->s7 : Symbol(s7, Decl(logicalAndOperatorStrictMode.ts, 25, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>s7 : Symbol(s7, Decl(logicalAndOperatorStrictMode.ts, 24, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const s8 = s && z; ->s8 : Symbol(s8, Decl(logicalAndOperatorStrictMode.ts, 26, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>s8 : Symbol(s8, Decl(logicalAndOperatorStrictMode.ts, 25, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const x1 = x && a; ->x1 : Symbol(x1, Decl(logicalAndOperatorStrictMode.ts, 28, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>x1 : Symbol(x1, Decl(logicalAndOperatorStrictMode.ts, 27, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const x2 = x && s; ->x2 : Symbol(x2, Decl(logicalAndOperatorStrictMode.ts, 29, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>x2 : Symbol(x2, Decl(logicalAndOperatorStrictMode.ts, 28, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const x3 = x && x; ->x3 : Symbol(x3, Decl(logicalAndOperatorStrictMode.ts, 30, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>x3 : Symbol(x3, Decl(logicalAndOperatorStrictMode.ts, 29, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const x4 = x && b; ->x4 : Symbol(x4, Decl(logicalAndOperatorStrictMode.ts, 31, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>x4 : Symbol(x4, Decl(logicalAndOperatorStrictMode.ts, 30, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const x5 = x && v; ->x5 : Symbol(x5, Decl(logicalAndOperatorStrictMode.ts, 32, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>x5 : Symbol(x5, Decl(logicalAndOperatorStrictMode.ts, 31, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const x6 = x && u; ->x6 : Symbol(x6, Decl(logicalAndOperatorStrictMode.ts, 33, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>x6 : Symbol(x6, Decl(logicalAndOperatorStrictMode.ts, 32, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const x7 = x && n; ->x7 : Symbol(x7, Decl(logicalAndOperatorStrictMode.ts, 34, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>x7 : Symbol(x7, Decl(logicalAndOperatorStrictMode.ts, 33, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const x8 = x && z; ->x8 : Symbol(x8, Decl(logicalAndOperatorStrictMode.ts, 35, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>x8 : Symbol(x8, Decl(logicalAndOperatorStrictMode.ts, 34, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const b1 = b && a; ->b1 : Symbol(b1, Decl(logicalAndOperatorStrictMode.ts, 37, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>b1 : Symbol(b1, Decl(logicalAndOperatorStrictMode.ts, 36, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const b2 = b && s; ->b2 : Symbol(b2, Decl(logicalAndOperatorStrictMode.ts, 38, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>b2 : Symbol(b2, Decl(logicalAndOperatorStrictMode.ts, 37, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const b3 = b && x; ->b3 : Symbol(b3, Decl(logicalAndOperatorStrictMode.ts, 39, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>b3 : Symbol(b3, Decl(logicalAndOperatorStrictMode.ts, 38, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const b4 = b && b; ->b4 : Symbol(b4, Decl(logicalAndOperatorStrictMode.ts, 40, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>b4 : Symbol(b4, Decl(logicalAndOperatorStrictMode.ts, 39, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const b5 = b && v; ->b5 : Symbol(b5, Decl(logicalAndOperatorStrictMode.ts, 41, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>b5 : Symbol(b5, Decl(logicalAndOperatorStrictMode.ts, 40, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const b6 = b && u; ->b6 : Symbol(b6, Decl(logicalAndOperatorStrictMode.ts, 42, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>b6 : Symbol(b6, Decl(logicalAndOperatorStrictMode.ts, 41, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const b7 = b && n; ->b7 : Symbol(b7, Decl(logicalAndOperatorStrictMode.ts, 43, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>b7 : Symbol(b7, Decl(logicalAndOperatorStrictMode.ts, 42, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const b8 = b && z; ->b8 : Symbol(b8, Decl(logicalAndOperatorStrictMode.ts, 44, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>b8 : Symbol(b8, Decl(logicalAndOperatorStrictMode.ts, 43, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const v1 = v && a; ->v1 : Symbol(v1, Decl(logicalAndOperatorStrictMode.ts, 46, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>v1 : Symbol(v1, Decl(logicalAndOperatorStrictMode.ts, 45, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const v2 = v && s; ->v2 : Symbol(v2, Decl(logicalAndOperatorStrictMode.ts, 47, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>v2 : Symbol(v2, Decl(logicalAndOperatorStrictMode.ts, 46, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const v3 = v && x; ->v3 : Symbol(v3, Decl(logicalAndOperatorStrictMode.ts, 48, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>v3 : Symbol(v3, Decl(logicalAndOperatorStrictMode.ts, 47, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const v4 = v && b; ->v4 : Symbol(v4, Decl(logicalAndOperatorStrictMode.ts, 49, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>v4 : Symbol(v4, Decl(logicalAndOperatorStrictMode.ts, 48, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const v5 = v && v; ->v5 : Symbol(v5, Decl(logicalAndOperatorStrictMode.ts, 50, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>v5 : Symbol(v5, Decl(logicalAndOperatorStrictMode.ts, 49, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const v6 = v && u; ->v6 : Symbol(v6, Decl(logicalAndOperatorStrictMode.ts, 51, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>v6 : Symbol(v6, Decl(logicalAndOperatorStrictMode.ts, 50, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const v7 = v && n; ->v7 : Symbol(v7, Decl(logicalAndOperatorStrictMode.ts, 52, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>v7 : Symbol(v7, Decl(logicalAndOperatorStrictMode.ts, 51, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const v8 = v && z; ->v8 : Symbol(v8, Decl(logicalAndOperatorStrictMode.ts, 53, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>v8 : Symbol(v8, Decl(logicalAndOperatorStrictMode.ts, 52, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const u1 = u && a; ->u1 : Symbol(u1, Decl(logicalAndOperatorStrictMode.ts, 55, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>u1 : Symbol(u1, Decl(logicalAndOperatorStrictMode.ts, 54, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const u2 = u && s; ->u2 : Symbol(u2, Decl(logicalAndOperatorStrictMode.ts, 56, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>u2 : Symbol(u2, Decl(logicalAndOperatorStrictMode.ts, 55, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const u3 = u && x; ->u3 : Symbol(u3, Decl(logicalAndOperatorStrictMode.ts, 57, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>u3 : Symbol(u3, Decl(logicalAndOperatorStrictMode.ts, 56, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const u4 = u && b; ->u4 : Symbol(u4, Decl(logicalAndOperatorStrictMode.ts, 58, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>u4 : Symbol(u4, Decl(logicalAndOperatorStrictMode.ts, 57, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const u5 = u && v; ->u5 : Symbol(u5, Decl(logicalAndOperatorStrictMode.ts, 59, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>u5 : Symbol(u5, Decl(logicalAndOperatorStrictMode.ts, 58, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const u6 = u && u; ->u6 : Symbol(u6, Decl(logicalAndOperatorStrictMode.ts, 60, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>u6 : Symbol(u6, Decl(logicalAndOperatorStrictMode.ts, 59, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const u7 = u && n; ->u7 : Symbol(u7, Decl(logicalAndOperatorStrictMode.ts, 61, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>u7 : Symbol(u7, Decl(logicalAndOperatorStrictMode.ts, 60, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const u8 = u && z; ->u8 : Symbol(u8, Decl(logicalAndOperatorStrictMode.ts, 62, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>u8 : Symbol(u8, Decl(logicalAndOperatorStrictMode.ts, 61, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const n1 = n && a; ->n1 : Symbol(n1, Decl(logicalAndOperatorStrictMode.ts, 64, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>n1 : Symbol(n1, Decl(logicalAndOperatorStrictMode.ts, 63, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const n2 = n && s; ->n2 : Symbol(n2, Decl(logicalAndOperatorStrictMode.ts, 65, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>n2 : Symbol(n2, Decl(logicalAndOperatorStrictMode.ts, 64, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const n3 = n && x; ->n3 : Symbol(n3, Decl(logicalAndOperatorStrictMode.ts, 66, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>n3 : Symbol(n3, Decl(logicalAndOperatorStrictMode.ts, 65, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const n4 = n && b; ->n4 : Symbol(n4, Decl(logicalAndOperatorStrictMode.ts, 67, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>n4 : Symbol(n4, Decl(logicalAndOperatorStrictMode.ts, 66, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const n5 = n && v; ->n5 : Symbol(n5, Decl(logicalAndOperatorStrictMode.ts, 68, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>n5 : Symbol(n5, Decl(logicalAndOperatorStrictMode.ts, 67, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const n6 = n && u; ->n6 : Symbol(n6, Decl(logicalAndOperatorStrictMode.ts, 69, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>n6 : Symbol(n6, Decl(logicalAndOperatorStrictMode.ts, 68, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const n7 = n && n; ->n7 : Symbol(n7, Decl(logicalAndOperatorStrictMode.ts, 70, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>n7 : Symbol(n7, Decl(logicalAndOperatorStrictMode.ts, 69, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const n8 = n && z; ->n8 : Symbol(n8, Decl(logicalAndOperatorStrictMode.ts, 71, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>n8 : Symbol(n8, Decl(logicalAndOperatorStrictMode.ts, 70, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) const z1 = z && a; ->z1 : Symbol(z1, Decl(logicalAndOperatorStrictMode.ts, 73, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) +>z1 : Symbol(z1, Decl(logicalAndOperatorStrictMode.ts, 72, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>a : Symbol(a, Decl(logicalAndOperatorStrictMode.ts, 0, 5)) const z2 = z && s; ->z2 : Symbol(z2, Decl(logicalAndOperatorStrictMode.ts, 74, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) +>z2 : Symbol(z2, Decl(logicalAndOperatorStrictMode.ts, 73, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>s : Symbol(s, Decl(logicalAndOperatorStrictMode.ts, 1, 5)) const z3 = z && x; ->z3 : Symbol(z3, Decl(logicalAndOperatorStrictMode.ts, 75, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) +>z3 : Symbol(z3, Decl(logicalAndOperatorStrictMode.ts, 74, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>x : Symbol(x, Decl(logicalAndOperatorStrictMode.ts, 2, 5)) const z4 = z && b; ->z4 : Symbol(z4, Decl(logicalAndOperatorStrictMode.ts, 76, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) +>z4 : Symbol(z4, Decl(logicalAndOperatorStrictMode.ts, 75, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>b : Symbol(b, Decl(logicalAndOperatorStrictMode.ts, 3, 5)) const z5 = z && v; ->z5 : Symbol(z5, Decl(logicalAndOperatorStrictMode.ts, 77, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) +>z5 : Symbol(z5, Decl(logicalAndOperatorStrictMode.ts, 76, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>v : Symbol(v, Decl(logicalAndOperatorStrictMode.ts, 4, 5)) const z6 = z && u; ->z6 : Symbol(z6, Decl(logicalAndOperatorStrictMode.ts, 78, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) +>z6 : Symbol(z6, Decl(logicalAndOperatorStrictMode.ts, 77, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>u : Symbol(u, Decl(logicalAndOperatorStrictMode.ts, 5, 5)) const z7 = z && n; ->z7 : Symbol(z7, Decl(logicalAndOperatorStrictMode.ts, 79, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>z7 : Symbol(z7, Decl(logicalAndOperatorStrictMode.ts, 78, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>n : Symbol(n, Decl(logicalAndOperatorStrictMode.ts, 6, 5)) const z8 = z && z; ->z8 : Symbol(z8, Decl(logicalAndOperatorStrictMode.ts, 80, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) ->z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 8, 5)) +>z8 : Symbol(z8, Decl(logicalAndOperatorStrictMode.ts, 79, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) +>z : Symbol(z, Decl(logicalAndOperatorStrictMode.ts, 7, 5)) diff --git a/tests/baselines/reference/logicalAndOperatorStrictMode.types b/tests/baselines/reference/logicalAndOperatorStrictMode.types index 892da9851209f..2d7ef648aeeac 100644 --- a/tests/baselines/reference/logicalAndOperatorStrictMode.types +++ b/tests/baselines/reference/logicalAndOperatorStrictMode.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/binaryOperators/logicalAndOperator/logicalAndOperatorStrictMode.ts === - const a = [0]; >a : number[] >[0] : number[] diff --git a/tests/baselines/reference/looseThisTypeInFunctions.errors.txt b/tests/baselines/reference/looseThisTypeInFunctions.errors.txt index cf4dcbd7dd55d..7e12a71440685 100644 --- a/tests/baselines/reference/looseThisTypeInFunctions.errors.txt +++ b/tests/baselines/reference/looseThisTypeInFunctions.errors.txt @@ -1,14 +1,13 @@ -tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(22,1): error TS2322: Type '(this: C, m: number) => number' is not assignable to type '(this: void, m: number) => number'. +tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(21,1): error TS2322: Type '(this: C, m: number) => number' is not assignable to type '(this: void, m: number) => number'. The 'this' types of each signature are incompatible. Type 'void' is not assignable to type 'C'. -tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(26,27): error TS2339: Property 'length' does not exist on type 'number'. -tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(34,28): error TS2339: Property 'length' does not exist on type 'number'. -tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(38,9): error TS2684: The 'this' context of type 'void' is not assignable to method's 'this' of type 'I'. -tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(47,20): error TS2339: Property 'length' does not exist on type 'number'. +tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(25,27): error TS2339: Property 'length' does not exist on type 'number'. +tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(33,28): error TS2339: Property 'length' does not exist on type 'number'. +tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(37,9): error TS2684: The 'this' context of type 'void' is not assignable to method's 'this' of type 'I'. +tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts(46,20): error TS2339: Property 'length' does not exist on type 'number'. ==== tests/cases/conformance/types/thisType/looseThisTypeInFunctions.ts (5 errors) ==== - interface I { n: number; explicitThis(this: this, m: number): number; diff --git a/tests/baselines/reference/looseThisTypeInFunctions.js b/tests/baselines/reference/looseThisTypeInFunctions.js index 3e97691ade2ed..cb1fbcc8b9572 100644 --- a/tests/baselines/reference/looseThisTypeInFunctions.js +++ b/tests/baselines/reference/looseThisTypeInFunctions.js @@ -1,5 +1,4 @@ //// [looseThisTypeInFunctions.ts] - interface I { n: number; explicitThis(this: this, m: number): number; diff --git a/tests/baselines/reference/malformedTags.js b/tests/baselines/reference/malformedTags.js index 33b2c1e6f4179..320669c94628a 100644 --- a/tests/baselines/reference/malformedTags.js +++ b/tests/baselines/reference/malformedTags.js @@ -1,5 +1,4 @@ //// [myFile02.js] - /** * Checks if `value` is classified as an `Array` object. * diff --git a/tests/baselines/reference/malformedTags.symbols b/tests/baselines/reference/malformedTags.symbols index df953a8249735..cd98f2a59a30b 100644 --- a/tests/baselines/reference/malformedTags.symbols +++ b/tests/baselines/reference/malformedTags.symbols @@ -1,12 +1,11 @@ === tests/cases/conformance/salsa/myFile02.js === - /** * Checks if `value` is classified as an `Array` object. * * @type Function */ var isArray = Array.isArray; ->isArray : Symbol(isArray, Decl(myFile02.js, 6, 3)) +>isArray : Symbol(isArray, Decl(myFile02.js, 5, 3)) >Array.isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/malformedTags.types b/tests/baselines/reference/malformedTags.types index acf442f7cba09..b4f7daecd8f62 100644 --- a/tests/baselines/reference/malformedTags.types +++ b/tests/baselines/reference/malformedTags.types @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/myFile02.js === - /** * Checks if `value` is classified as an `Array` object. * diff --git a/tests/baselines/reference/mapOnTupleTypes01.js b/tests/baselines/reference/mapOnTupleTypes01.js index 9f22aa637535d..565988bfd73f6 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.js +++ b/tests/baselines/reference/mapOnTupleTypes01.js @@ -1,5 +1,4 @@ //// [mapOnTupleTypes01.ts] - export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); // Length 1 diff --git a/tests/baselines/reference/mapOnTupleTypes01.symbols b/tests/baselines/reference/mapOnTupleTypes01.symbols index 0733b1d5b022a..687439199fe95 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.symbols +++ b/tests/baselines/reference/mapOnTupleTypes01.symbols @@ -1,119 +1,118 @@ === tests/cases/compiler/mapOnTupleTypes01.ts === - export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); ->mapOnLooseArrayLiteral : Symbol(mapOnLooseArrayLiteral, Decl(mapOnTupleTypes01.ts, 1, 10)) +>mapOnLooseArrayLiteral : Symbol(mapOnLooseArrayLiteral, Decl(mapOnTupleTypes01.ts, 0, 10)) >[1, 2, 3, 4].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 0, 53)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 0, 53)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 0, 53)) // Length 1 let numTuple: [number] = [1]; ->numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 5, 3)) +>numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 4, 3)) export let a = numTuple.map(x => x * x); ->a : Symbol(a, Decl(mapOnTupleTypes01.ts, 6, 10)) +>a : Symbol(a, Decl(mapOnTupleTypes01.ts, 5, 10)) >numTuple.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 5, 3)) +>numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 4, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 5, 28)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 5, 28)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 5, 28)) // Length 2 let numNum: [number, number] = [ 100, 100]; ->numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 10, 3)) +>numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 9, 3)) let strStr: [string, string] = ["hello", "hello"]; ->strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 11, 3)) +>strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 10, 3)) let numStr: [number, string] = [ 100, "hello"]; ->numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 12, 3)) +>numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 11, 3)) export let b = numNum.map(n => n * n); ->b : Symbol(b, Decl(mapOnTupleTypes01.ts, 14, 10)) +>b : Symbol(b, Decl(mapOnTupleTypes01.ts, 13, 10)) >numNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 10, 3)) +>numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 9, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 13, 26)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 13, 26)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 13, 26)) export let c = strStr.map(s => s.charCodeAt(0)); ->c : Symbol(c, Decl(mapOnTupleTypes01.ts, 15, 10)) +>c : Symbol(c, Decl(mapOnTupleTypes01.ts, 14, 10)) >strStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 11, 3)) +>strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 10, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26)) +>s : Symbol(s, Decl(mapOnTupleTypes01.ts, 14, 26)) >s.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26)) +>s : Symbol(s, Decl(mapOnTupleTypes01.ts, 14, 26)) >charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) export let d = numStr.map(x => x); ->d : Symbol(d, Decl(mapOnTupleTypes01.ts, 16, 10)) +>d : Symbol(d, Decl(mapOnTupleTypes01.ts, 15, 10)) >numStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 12, 3)) +>numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 11, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26)) ->x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 15, 26)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 15, 26)) // Length 3 let numNumNum: [number, number, number] = [1, 2, 3]; ->numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 20, 3)) +>numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 19, 3)) export let e = numNumNum.map(n => n * n); ->e : Symbol(e, Decl(mapOnTupleTypes01.ts, 22, 10)) +>e : Symbol(e, Decl(mapOnTupleTypes01.ts, 21, 10)) >numNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 20, 3)) +>numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 19, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 21, 29)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 21, 29)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 21, 29)) // Length 4 let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4]; ->numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 26, 3)) +>numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 25, 3)) export let f = numNumNumNum.map(n => n * n); ->f : Symbol(f, Decl(mapOnTupleTypes01.ts, 28, 10)) +>f : Symbol(f, Decl(mapOnTupleTypes01.ts, 27, 10)) >numNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 26, 3)) +>numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 25, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 27, 32)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 27, 32)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 27, 32)) // Length 5 let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5]; ->numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) +>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 31, 3)) export let g = numNumNumNumNum.map(n => n * n); ->g : Symbol(g, Decl(mapOnTupleTypes01.ts, 34, 10)) +>g : Symbol(g, Decl(mapOnTupleTypes01.ts, 33, 10)) >numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) +>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 31, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 33, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 33, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 33, 35)) // Length 6 let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2, 3, 4, 5, 6]; ->numNumNumNumNumNum : Symbol(numNumNumNumNumNum, Decl(mapOnTupleTypes01.ts, 39, 3)) +>numNumNumNumNumNum : Symbol(numNumNumNumNumNum, Decl(mapOnTupleTypes01.ts, 38, 3)) export let h = numNumNumNumNum.map(n => n * n); ->h : Symbol(h, Decl(mapOnTupleTypes01.ts, 41, 10)) +>h : Symbol(h, Decl(mapOnTupleTypes01.ts, 40, 10)) >numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) +>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 31, 3)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) ->n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 40, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 40, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 40, 35)) diff --git a/tests/baselines/reference/mapOnTupleTypes01.types b/tests/baselines/reference/mapOnTupleTypes01.types index b8230d3fdf55f..e55edda112469 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.types +++ b/tests/baselines/reference/mapOnTupleTypes01.types @@ -1,5 +1,4 @@ === tests/cases/compiler/mapOnTupleTypes01.ts === - export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); >mapOnLooseArrayLiteral : number[] >[1, 2, 3, 4].map(n => n * n) : number[] diff --git a/tests/baselines/reference/mapOnTupleTypes02.js b/tests/baselines/reference/mapOnTupleTypes02.js index ca835751a7a7d..2fd4daab16bf5 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.js +++ b/tests/baselines/reference/mapOnTupleTypes02.js @@ -1,5 +1,4 @@ //// [mapOnTupleTypes02.ts] - export type Point = [number, number]; export function increment(point: Point) { diff --git a/tests/baselines/reference/mapOnTupleTypes02.symbols b/tests/baselines/reference/mapOnTupleTypes02.symbols index 6453caace910f..b96b3be3134ee 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.symbols +++ b/tests/baselines/reference/mapOnTupleTypes02.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/mapOnTupleTypes02.ts === - export type Point = [number, number]; >Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0)) export function increment(point: Point) { ->increment : Symbol(increment, Decl(mapOnTupleTypes02.ts, 1, 37)) ->point : Symbol(point, Decl(mapOnTupleTypes02.ts, 3, 26)) +>increment : Symbol(increment, Decl(mapOnTupleTypes02.ts, 0, 37)) +>point : Symbol(point, Decl(mapOnTupleTypes02.ts, 2, 26)) >Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0)) return point.map(d => d + 1); >point.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->point : Symbol(point, Decl(mapOnTupleTypes02.ts, 3, 26)) +>point : Symbol(point, Decl(mapOnTupleTypes02.ts, 2, 26)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19)) ->d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19)) +>d : Symbol(d, Decl(mapOnTupleTypes02.ts, 3, 19)) +>d : Symbol(d, Decl(mapOnTupleTypes02.ts, 3, 19)) } diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types index 5ec555ebf17cd..1a354dce354b1 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.types +++ b/tests/baselines/reference/mapOnTupleTypes02.types @@ -1,5 +1,4 @@ === tests/cases/compiler/mapOnTupleTypes02.ts === - export type Point = [number, number]; >Point : [number, number] diff --git a/tests/baselines/reference/mappedTypeErrors.errors.txt b/tests/baselines/reference/mappedTypeErrors.errors.txt index c7571295521c1..3245f9932f009 100644 --- a/tests/baselines/reference/mappedTypeErrors.errors.txt +++ b/tests/baselines/reference/mappedTypeErrors.errors.txt @@ -1,56 +1,55 @@ -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(20,20): error TS2313: Type parameter 'P' has a circular constraint. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(21,20): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(22,20): error TS2322: Type 'Date' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(23,19): error TS2344: Type 'Date' does not satisfy the constraint 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(26,24): error TS2344: Type '"foo"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(27,24): error TS2344: Type '"name" | "foo"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(19,20): error TS2313: Type parameter 'P' has a circular constraint. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(20,20): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(21,20): error TS2322: Type 'Date' is not assignable to type 'string'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(22,19): error TS2344: Type 'Date' does not satisfy the constraint 'string'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(25,24): error TS2344: Type '"foo"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(26,24): error TS2344: Type '"name" | "foo"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. Type '"foo"' is not assignable to type '"name" | "width" | "height" | "visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(29,24): error TS2344: Type '"x" | "y"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(28,24): error TS2344: Type '"x" | "y"' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. Type '"x"' is not assignable to type '"name" | "width" | "height" | "visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(31,24): error TS2344: Type 'undefined' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(34,24): error TS2344: Type 'T' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(30,24): error TS2344: Type 'undefined' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(33,24): error TS2344: Type 'T' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. Type 'T' is not assignable to type '"visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(38,24): error TS2344: Type 'T' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(37,24): error TS2344: Type 'T' does not satisfy the constraint '"name" | "width" | "height" | "visible"'. Type 'string | number' is not assignable to type '"name" | "width" | "height" | "visible"'. Type 'string' is not assignable to type '"name" | "width" | "height" | "visible"'. Type 'T' is not assignable to type '"visible"'. Type 'string | number' is not assignable to type '"visible"'. Type 'string' is not assignable to type '"visible"'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(60,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ [P in keyof T]?: T[P] | undefined; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(61,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ readonly [P in keyof T]: T[P]; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(62,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ readonly [P in keyof T]?: T[P] | undefined; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(67,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ [P in keyof T]: T[P][]; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(76,45): error TS2345: Argument of type '{ x: number; }' is not assignable to parameter of type 'Readonly<{ x: number; y: number; }>'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(59,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ [P in keyof T]?: T[P] | undefined; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(60,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ readonly [P in keyof T]: T[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(61,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ readonly [P in keyof T]?: T[P] | undefined; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(66,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type '{ [P in keyof T]: T[P]; }', but here has type '{ [P in keyof T]: T[P][]; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(75,45): error TS2345: Argument of type '{ x: number; }' is not assignable to parameter of type 'Readonly<{ x: number; y: number; }>'. Property 'y' is missing in type '{ x: number; }'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(78,59): error TS2345: Argument of type '{ x: number; y: number; z: number; }' is not assignable to parameter of type 'Readonly<{ x: number; y: number; }>'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(77,59): error TS2345: Argument of type '{ x: number; y: number; z: number; }' is not assignable to parameter of type 'Readonly<{ x: number; y: number; }>'. Object literal may only specify known properties, and 'z' does not exist in type 'Readonly<{ x: number; y: number; }>'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(84,58): error TS2345: Argument of type '{ x: number; y: number; z: number; }' is not assignable to parameter of type 'Partial<{ x: number; y: number; }>'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(83,58): error TS2345: Argument of type '{ x: number; y: number; z: number; }' is not assignable to parameter of type 'Partial<{ x: number; y: number; }>'. Object literal may only specify known properties, and 'z' does not exist in type 'Partial<{ x: number; y: number; }>'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(106,15): error TS2345: Argument of type '{ a: undefined; }' is not assignable to parameter of type 'Pick'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(105,15): error TS2345: Argument of type '{ a: undefined; }' is not assignable to parameter of type 'Pick'. Types of property 'a' are incompatible. Type 'undefined' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(107,17): error TS2345: Argument of type '{ c: boolean; }' is not assignable to parameter of type 'Pick'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(106,17): error TS2345: Argument of type '{ c: boolean; }' is not assignable to parameter of type 'Pick'. Object literal may only specify known properties, and 'c' does not exist in type 'Pick'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(124,12): error TS2345: Argument of type '{ a: undefined; }' is not assignable to parameter of type 'Pick'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(123,12): error TS2345: Argument of type '{ a: undefined; }' is not assignable to parameter of type 'Pick'. Types of property 'a' are incompatible. Type 'undefined' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(125,14): error TS2345: Argument of type '{ c: boolean; }' is not assignable to parameter of type 'Pick'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(124,14): error TS2345: Argument of type '{ c: boolean; }' is not assignable to parameter of type 'Pick'. Object literal may only specify known properties, and 'c' does not exist in type 'Pick'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(129,5): error TS2322: Type '{ a: string; }' is not assignable to type 'T2'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(128,5): error TS2322: Type '{ a: string; }' is not assignable to type 'T2'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number | undefined'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(130,5): error TS2322: Type '{ a: string; }' is not assignable to type 'Partial'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(129,5): error TS2322: Type '{ a: string; }' is not assignable to type 'Partial'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number | undefined'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(131,5): error TS2322: Type '{ a: string; }' is not assignable to type '{ [x: string]: any; a?: number | undefined; }'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(130,5): error TS2322: Type '{ a: string; }' is not assignable to type '{ [x: string]: any; a?: number | undefined; }'. Types of property 'a' are incompatible. Type 'string' is not assignable to type 'number | undefined'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(137,16): error TS2322: Type 'T' is not assignable to type 'string'. -tests/cases/conformance/types/mapped/mappedTypeErrors.ts(137,21): error TS2536: Type 'P' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(136,16): error TS2322: Type 'T' is not assignable to type 'string'. +tests/cases/conformance/types/mapped/mappedTypeErrors.ts(136,21): error TS2536: Type 'P' cannot be used to index type 'T'. ==== tests/cases/conformance/types/mapped/mappedTypeErrors.ts (26 errors) ==== - interface Shape { name: string; width: number; diff --git a/tests/baselines/reference/mappedTypeErrors.js b/tests/baselines/reference/mappedTypeErrors.js index f194b6193fc37..dcaa737edd85c 100644 --- a/tests/baselines/reference/mappedTypeErrors.js +++ b/tests/baselines/reference/mappedTypeErrors.js @@ -1,5 +1,4 @@ //// [mappedTypeErrors.ts] - interface Shape { name: string; width: number; diff --git a/tests/baselines/reference/mappedTypeModifiers.js b/tests/baselines/reference/mappedTypeModifiers.js index a247d18f2d4b2..e4d2c513d4c86 100644 --- a/tests/baselines/reference/mappedTypeModifiers.js +++ b/tests/baselines/reference/mappedTypeModifiers.js @@ -1,5 +1,4 @@ //// [mappedTypeModifiers.ts] - type T = { a: number, b: string }; type TP = { a?: number, b?: string }; type TR = { readonly a: number, readonly b: string }; diff --git a/tests/baselines/reference/mappedTypeModifiers.symbols b/tests/baselines/reference/mappedTypeModifiers.symbols index b2b8faed4cf89..2aa6492d99fd0 100644 --- a/tests/baselines/reference/mappedTypeModifiers.symbols +++ b/tests/baselines/reference/mappedTypeModifiers.symbols @@ -1,63 +1,62 @@ === tests/cases/conformance/types/mapped/mappedTypeModifiers.ts === - type T = { a: number, b: string }; >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 1, 10)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 1, 21)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 0, 10)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 0, 21)) type TP = { a?: number, b?: string }; ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 2, 11)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 2, 23)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 1, 11)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 1, 23)) type TR = { readonly a: number, readonly b: string }; ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 3, 11)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 3, 31)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 2, 11)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 2, 31)) type TPR = { readonly a?: number, readonly b?: string }; ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 4, 12)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 4, 33)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 3, 12)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 3, 33)) var v00: "a" | "b"; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) var v00: keyof T; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v00: keyof TP; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) var v00: keyof TR; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) var v00: keyof TPR; ->v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3), Decl(mappedTypeModifiers.ts, 10, 3)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) +>v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) var v01: T; ->v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3), Decl(mappedTypeModifiers.ts, 15, 3)) +>v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 11, 3), Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v01: { [P in keyof T]: T[P] }; ->v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3), Decl(mappedTypeModifiers.ts, 15, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 13, 12)) +>v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 11, 3), Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 12, 12)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 13, 12)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 12, 12)) var v01: Pick; ->v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3), Decl(mappedTypeModifiers.ts, 15, 3)) +>v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 11, 3), Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v01: Pick, keyof T>; ->v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3), Decl(mappedTypeModifiers.ts, 15, 3)) +>v01 : Symbol(v01, Decl(mappedTypeModifiers.ts, 11, 3), Decl(mappedTypeModifiers.ts, 12, 3), Decl(mappedTypeModifiers.ts, 13, 3), Decl(mappedTypeModifiers.ts, 14, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) @@ -65,368 +64,368 @@ var v01: Pick, keyof T>; >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v02: TP; ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) var v02: { [P in keyof T]?: T[P] }; ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 18, 12)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 17, 12)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 18, 12)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 17, 12)) var v02: Partial; ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v02: { [P in keyof TP]: TP[P] } ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 20, 12)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 20, 12)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 19, 12)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 19, 12)) var v02: Pick; ->v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3), Decl(mappedTypeModifiers.ts, 21, 3)) +>v02 : Symbol(v02, Decl(mappedTypeModifiers.ts, 16, 3), Decl(mappedTypeModifiers.ts, 17, 3), Decl(mappedTypeModifiers.ts, 18, 3), Decl(mappedTypeModifiers.ts, 19, 3), Decl(mappedTypeModifiers.ts, 20, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) var v03: TR; ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) var v03: { readonly [P in keyof T]: T[P] }; ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 24, 21)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 23, 21)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 24, 21)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 23, 21)) var v03: Readonly; ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v03: { [P in keyof TR]: TR[P] } ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 26, 12)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 26, 12)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 25, 12)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 25, 12)) var v03: Pick; ->v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3), Decl(mappedTypeModifiers.ts, 27, 3)) +>v03 : Symbol(v03, Decl(mappedTypeModifiers.ts, 22, 3), Decl(mappedTypeModifiers.ts, 23, 3), Decl(mappedTypeModifiers.ts, 24, 3), Decl(mappedTypeModifiers.ts, 25, 3), Decl(mappedTypeModifiers.ts, 26, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) var v04: TPR; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) var v04: { readonly [P in keyof T]?: T[P] }; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 30, 21)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 29, 21)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 30, 21)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 29, 21)) var v04: Partial; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 2, 37)) +>TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37)) var v04: Readonly; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 1, 34)) +>TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34)) var v04: Partial>; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v04: Readonly>; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) var v04: { [P in keyof TPR]: TPR[P] } ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 35, 12)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 35, 12)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 34, 12)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 34, 12)) var v04: Pick; ->v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3), Decl(mappedTypeModifiers.ts, 36, 3)) +>v04 : Symbol(v04, Decl(mappedTypeModifiers.ts, 28, 3), Decl(mappedTypeModifiers.ts, 29, 3), Decl(mappedTypeModifiers.ts, 30, 3), Decl(mappedTypeModifiers.ts, 31, 3), Decl(mappedTypeModifiers.ts, 32, 3), Decl(mappedTypeModifiers.ts, 33, 3), Decl(mappedTypeModifiers.ts, 34, 3), Decl(mappedTypeModifiers.ts, 35, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 3, 53)) +>TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53)) >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0)) type Boxified = { [P in keyof T]: { x: T[P] } }; ->Boxified : Symbol(Boxified, Decl(mappedTypeModifiers.ts, 36, 28)) ->T : Symbol(T, Decl(mappedTypeModifiers.ts, 38, 14)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 38, 22)) ->T : Symbol(T, Decl(mappedTypeModifiers.ts, 38, 14)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 38, 38)) ->T : Symbol(T, Decl(mappedTypeModifiers.ts, 38, 14)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 38, 22)) +>Boxified : Symbol(Boxified, Decl(mappedTypeModifiers.ts, 35, 28)) +>T : Symbol(T, Decl(mappedTypeModifiers.ts, 37, 14)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 37, 22)) +>T : Symbol(T, Decl(mappedTypeModifiers.ts, 37, 14)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 37, 38)) +>T : Symbol(T, Decl(mappedTypeModifiers.ts, 37, 14)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 37, 22)) type B = { a: { x: number }, b: { x: string } }; ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 40, 10)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 15)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 40, 28)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 33)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 39, 10)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 39, 15)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 39, 28)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 39, 33)) type BP = { a?: { x: number }, b?: { x: string } }; ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 41, 11)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 17)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 41, 30)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 36)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 40, 11)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 17)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 40, 30)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 36)) type BR = { readonly a: { x: number }, readonly b: { x: string } }; ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 42, 11)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 25)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 42, 38)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 52)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 41, 11)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 25)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 41, 38)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 52)) type BPR = { readonly a?: { x: number }, readonly b?: { x: string } }; ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) ->a : Symbol(a, Decl(mappedTypeModifiers.ts, 43, 12)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 43, 27)) ->b : Symbol(b, Decl(mappedTypeModifiers.ts, 43, 40)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 43, 55)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) +>a : Symbol(a, Decl(mappedTypeModifiers.ts, 42, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 27)) +>b : Symbol(b, Decl(mappedTypeModifiers.ts, 42, 40)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 55)) var b00: "a" | "b"; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) var b00: keyof B; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b00: keyof BP; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) var b00: keyof BR; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) var b00: keyof BPR; ->b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3), Decl(mappedTypeModifiers.ts, 49, 3)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) +>b00 : Symbol(b00, Decl(mappedTypeModifiers.ts, 44, 3), Decl(mappedTypeModifiers.ts, 45, 3), Decl(mappedTypeModifiers.ts, 46, 3), Decl(mappedTypeModifiers.ts, 47, 3), Decl(mappedTypeModifiers.ts, 48, 3)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) var b01: B; ->b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3), Decl(mappedTypeModifiers.ts, 54, 3)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 50, 3), Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b01: { [P in keyof B]: B[P] }; ->b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3), Decl(mappedTypeModifiers.ts, 54, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 52, 12)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 52, 12)) +>b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 50, 3), Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 51, 12)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 51, 12)) var b01: Pick; ->b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3), Decl(mappedTypeModifiers.ts, 54, 3)) +>b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 50, 3), Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b01: Pick, keyof B>; ->b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3), Decl(mappedTypeModifiers.ts, 54, 3)) +>b01 : Symbol(b01, Decl(mappedTypeModifiers.ts, 50, 3), Decl(mappedTypeModifiers.ts, 51, 3), Decl(mappedTypeModifiers.ts, 52, 3), Decl(mappedTypeModifiers.ts, 53, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b02: BP; ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) var b02: { [P in keyof B]?: B[P] }; ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 57, 12)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 57, 12)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 56, 12)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 56, 12)) var b02: Partial; ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b02: { [P in keyof BP]: BP[P] } ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 59, 12)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 59, 12)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 58, 12)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 58, 12)) var b02: Pick; ->b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3), Decl(mappedTypeModifiers.ts, 60, 3)) +>b02 : Symbol(b02, Decl(mappedTypeModifiers.ts, 55, 3), Decl(mappedTypeModifiers.ts, 56, 3), Decl(mappedTypeModifiers.ts, 57, 3), Decl(mappedTypeModifiers.ts, 58, 3), Decl(mappedTypeModifiers.ts, 59, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) var b03: BR; ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) var b03: { readonly [P in keyof B]: B[P] }; ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 63, 21)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 63, 21)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 62, 21)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 62, 21)) var b03: Readonly; ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b03: { [P in keyof BR]: BR[P] } ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 65, 12)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 65, 12)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 64, 12)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 64, 12)) var b03: Pick; ->b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3), Decl(mappedTypeModifiers.ts, 66, 3)) +>b03 : Symbol(b03, Decl(mappedTypeModifiers.ts, 61, 3), Decl(mappedTypeModifiers.ts, 62, 3), Decl(mappedTypeModifiers.ts, 63, 3), Decl(mappedTypeModifiers.ts, 64, 3), Decl(mappedTypeModifiers.ts, 65, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) var b04: BPR; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) var b04: { readonly [P in keyof B]?: B[P] }; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 69, 21)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 69, 21)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 68, 21)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 68, 21)) var b04: Partial
; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 41, 51)) +>BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51)) var b04: Readonly; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 40, 48)) +>BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48)) var b04: Partial>; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b04: Readonly>; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->B : Symbol(B, Decl(mappedTypeModifiers.ts, 38, 51)) +>B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51)) var b04: { [P in keyof BPR]: BPR[P] } ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 74, 12)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 74, 12)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 73, 12)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 73, 12)) var b04: Pick; ->b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3), Decl(mappedTypeModifiers.ts, 75, 3)) +>b04 : Symbol(b04, Decl(mappedTypeModifiers.ts, 67, 3), Decl(mappedTypeModifiers.ts, 68, 3), Decl(mappedTypeModifiers.ts, 69, 3), Decl(mappedTypeModifiers.ts, 70, 3), Decl(mappedTypeModifiers.ts, 71, 3), Decl(mappedTypeModifiers.ts, 72, 3), Decl(mappedTypeModifiers.ts, 73, 3), Decl(mappedTypeModifiers.ts, 74, 3)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) ->BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 42, 67)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) +>BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67)) type Foo = { prop: number, [x: string]: number }; ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) ->prop : Symbol(prop, Decl(mappedTypeModifiers.ts, 77, 12)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 77, 28)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) +>prop : Symbol(prop, Decl(mappedTypeModifiers.ts, 76, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 76, 28)) function f1(x: Partial) { ->f1 : Symbol(f1, Decl(mappedTypeModifiers.ts, 77, 49)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 79, 12)) +>f1 : Symbol(f1, Decl(mappedTypeModifiers.ts, 76, 49)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 78, 12)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) x.prop; // ok >x.prop : Symbol(prop) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 79, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 78, 12)) >prop : Symbol(prop) (x["other"] || 0).toFixed(); >(x["other"] || 0).toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 79, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 78, 12)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } function f2(x: Readonly) { ->f2 : Symbol(f2, Decl(mappedTypeModifiers.ts, 82, 1)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 84, 12)) +>f2 : Symbol(f2, Decl(mappedTypeModifiers.ts, 81, 1)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 83, 12)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) x.prop; // ok >x.prop : Symbol(prop) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 84, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 83, 12)) >prop : Symbol(prop) x["other"].toFixed(); >x["other"].toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 84, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 83, 12)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } function f3(x: Boxified) { ->f3 : Symbol(f3, Decl(mappedTypeModifiers.ts, 87, 1)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 89, 12)) ->Boxified : Symbol(Boxified, Decl(mappedTypeModifiers.ts, 36, 28)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) +>f3 : Symbol(f3, Decl(mappedTypeModifiers.ts, 86, 1)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 88, 12)) +>Boxified : Symbol(Boxified, Decl(mappedTypeModifiers.ts, 35, 28)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) x.prop; // ok >x.prop : Symbol(prop) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 89, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 88, 12)) >prop : Symbol(prop) x["other"].x.toFixed(); >x["other"].x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) ->x["other"].x : Symbol(x, Decl(mappedTypeModifiers.ts, 38, 38)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 89, 12)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 38, 38)) +>x["other"].x : Symbol(x, Decl(mappedTypeModifiers.ts, 37, 38)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 88, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 37, 38)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } function f4(x: { [P in keyof Foo]: Foo[P] }) { ->f4 : Symbol(f4, Decl(mappedTypeModifiers.ts, 92, 1)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 94, 12)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 94, 18)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) ->Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 75, 30)) ->P : Symbol(P, Decl(mappedTypeModifiers.ts, 94, 18)) +>f4 : Symbol(f4, Decl(mappedTypeModifiers.ts, 91, 1)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 93, 12)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 93, 18)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) +>Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30)) +>P : Symbol(P, Decl(mappedTypeModifiers.ts, 93, 18)) x.prop; // ok >x.prop : Symbol(prop) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 94, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 93, 12)) >prop : Symbol(prop) x["other"].toFixed(); >x["other"].toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(mappedTypeModifiers.ts, 94, 12)) +>x : Symbol(x, Decl(mappedTypeModifiers.ts, 93, 12)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/mappedTypeModifiers.types b/tests/baselines/reference/mappedTypeModifiers.types index 7771de023f1d2..b7c5c08ac52a3 100644 --- a/tests/baselines/reference/mappedTypeModifiers.types +++ b/tests/baselines/reference/mappedTypeModifiers.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypeModifiers.ts === - type T = { a: number, b: string }; >T : T >a : number diff --git a/tests/baselines/reference/mappedTypeRelationships.errors.txt b/tests/baselines/reference/mappedTypeRelationships.errors.txt index bc26bb272f51a..c54330e9b1677 100644 --- a/tests/baselines/reference/mappedTypeRelationships.errors.txt +++ b/tests/baselines/reference/mappedTypeRelationships.errors.txt @@ -1,66 +1,93 @@ -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(12,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(11,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T]'. Type 'T[string]' is not assignable to type 'U[keyof T]'. - Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(17,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T[keyof T]' is not assignable to type 'U[string]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T' is not assignable to type 'U'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(16,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. Type 'T[string]' is not assignable to type 'U[K]'. - Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(21,5): error TS2536: Type 'keyof U' cannot be used to index type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(22,5): error TS2322: Type 'T[keyof U]' is not assignable to type 'U[keyof U]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T[K]' is not assignable to type 'U[string]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T' is not assignable to type 'U'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(20,5): error TS2536: Type 'keyof U' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(21,5): error TS2322: Type 'T[keyof U]' is not assignable to type 'U[keyof U]'. Type 'T[string]' is not assignable to type 'U[keyof U]'. - Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(22,12): error TS2536: Type 'keyof U' cannot be used to index type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(26,5): error TS2536: Type 'K' cannot be used to index type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(27,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T[keyof U]' is not assignable to type 'U[string]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T' is not assignable to type 'U'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(21,12): error TS2536: Type 'keyof U' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(25,5): error TS2536: Type 'K' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(26,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. Type 'T[string]' is not assignable to type 'U[K]'. - Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(27,12): error TS2536: Type 'K' cannot be used to index type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(31,5): error TS2322: Type 'T[keyof T] | undefined' is not assignable to type 'T[keyof T]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T[K]' is not assignable to type 'U[string]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T' is not assignable to type 'U'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(26,12): error TS2536: Type 'K' cannot be used to index type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(30,5): error TS2322: Type 'T[keyof T] | undefined' is not assignable to type 'T[keyof T]'. Type 'undefined' is not assignable to type 'T[keyof T]'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(36,5): error TS2322: Type 'T[K] | undefined' is not assignable to type 'T[K]'. + Type 'undefined' is not assignable to type 'T[string]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(35,5): error TS2322: Type 'T[K] | undefined' is not assignable to type 'T[K]'. Type 'undefined' is not assignable to type 'T[K]'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(41,5): error TS2322: Type 'U[keyof T] | undefined' is not assignable to type 'T[keyof T]'. + Type 'undefined' is not assignable to type 'T[string]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(40,5): error TS2322: Type 'U[keyof T] | undefined' is not assignable to type 'T[keyof T]'. Type 'undefined' is not assignable to type 'T[keyof T]'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(42,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T] | undefined'. + Type 'undefined' is not assignable to type 'T[string]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(41,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T] | undefined'. Type 'T[string]' is not assignable to type 'U[keyof T] | undefined'. Type 'T[string]' is not assignable to type 'U[keyof T]'. Type 'T[keyof T]' is not assignable to type 'U[keyof T]'. Type 'T[string]' is not assignable to type 'U[keyof T]'. - Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(46,5): error TS2322: Type 'U[K] | undefined' is not assignable to type 'T[K]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T[keyof T]' is not assignable to type 'U[string]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T' is not assignable to type 'U'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(45,5): error TS2322: Type 'U[K] | undefined' is not assignable to type 'T[K]'. Type 'undefined' is not assignable to type 'T[K]'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(47,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K] | undefined'. + Type 'undefined' is not assignable to type 'T[string]'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(46,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K] | undefined'. Type 'T[string]' is not assignable to type 'U[K] | undefined'. Type 'T[string]' is not assignable to type 'U[K]'. Type 'T[K]' is not assignable to type 'U[K]'. Type 'T[string]' is not assignable to type 'U[K]'. - Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(52,5): error TS2542: Index signature in type 'Readonly' only permits reading. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(57,5): error TS2542: Index signature in type 'Readonly' only permits reading. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(62,5): error TS2542: Index signature in type 'Readonly' only permits reading. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(67,5): error TS2542: Index signature in type 'Readonly' only permits reading. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(71,5): error TS2322: Type 'Partial' is not assignable to type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(76,5): error TS2322: Type 'Partial' is not assignable to type 'T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(126,5): error TS2322: Type 'Partial' is not assignable to type 'Identity'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(142,5): error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T[K]' is not assignable to type 'U[string]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T' is not assignable to type 'U'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(51,5): error TS2542: Index signature in type 'Readonly' only permits reading. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(56,5): error TS2542: Index signature in type 'Readonly' only permits reading. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(61,5): error TS2542: Index signature in type 'Readonly' only permits reading. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(66,5): error TS2542: Index signature in type 'Readonly' only permits reading. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(70,5): error TS2322: Type 'Partial' is not assignable to type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(75,5): error TS2322: Type 'Partial' is not assignable to type 'T'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(125,5): error TS2322: Type 'Partial' is not assignable to type 'Identity'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(141,5): error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'. Type 'T[P]' is not assignable to type 'U[P]'. Type 'T[string]' is not assignable to type 'U[P]'. - Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(147,5): error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof U]: U[P]; }'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T[P]' is not assignable to type 'U[string]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T' is not assignable to type 'U'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(146,5): error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof U]: U[P]; }'. Type 'keyof U' is not assignable to type 'keyof T'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(152,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof T]: T[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(151,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof T]: T[P]; }'. Type 'keyof T' is not assignable to type 'K'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(157,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof U]: U[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(156,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof U]: U[P]; }'. Type 'keyof U' is not assignable to type 'K'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(162,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(161,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'. Type 'keyof T' is not assignable to type 'K'. -tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in K]: U[P]; }'. +tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(166,5): error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in K]: U[P]; }'. Type 'T[P]' is not assignable to type 'U[P]'. Type 'T[string]' is not assignable to type 'U[P]'. - Type 'T' is not assignable to type 'U'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T[P]' is not assignable to type 'U[string]'. + Type 'T[string]' is not assignable to type 'U[string]'. + Type 'T' is not assignable to type 'U'. ==== tests/cases/conformance/types/mapped/mappedTypeRelationships.ts (27 errors) ==== - function f1(x: T, k: keyof T) { return x[k]; } @@ -75,7 +102,10 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS ~~~~ !!! error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T]'. !!! error TS2322: Type 'T[string]' is not assignable to type 'U[keyof T]'. -!!! error TS2322: Type 'T' is not assignable to type 'U'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[keyof T]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. } function f4(x: T, y: U, k: K) { @@ -84,7 +114,10 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS ~~~~ !!! error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. !!! error TS2322: Type 'T[string]' is not assignable to type 'U[K]'. -!!! error TS2322: Type 'T' is not assignable to type 'U'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[K]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. } function f5(x: T, y: U, k: keyof U) { @@ -95,7 +128,10 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS ~~~~ !!! error TS2322: Type 'T[keyof U]' is not assignable to type 'U[keyof U]'. !!! error TS2322: Type 'T[string]' is not assignable to type 'U[keyof U]'. -!!! error TS2322: Type 'T' is not assignable to type 'U'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[keyof U]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. ~~~~ !!! error TS2536: Type 'keyof U' cannot be used to index type 'T'. } @@ -108,7 +144,10 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS ~~~~ !!! error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. !!! error TS2322: Type 'T[string]' is not assignable to type 'U[K]'. -!!! error TS2322: Type 'T' is not assignable to type 'U'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[K]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. ~~~~ !!! error TS2536: Type 'K' cannot be used to index type 'T'. } @@ -118,6 +157,7 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS ~~~~ !!! error TS2322: Type 'T[keyof T] | undefined' is not assignable to type 'T[keyof T]'. !!! error TS2322: Type 'undefined' is not assignable to type 'T[keyof T]'. +!!! error TS2322: Type 'undefined' is not assignable to type 'T[string]'. y[k] = x[k]; } @@ -126,6 +166,7 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS ~~~~ !!! error TS2322: Type 'T[K] | undefined' is not assignable to type 'T[K]'. !!! error TS2322: Type 'undefined' is not assignable to type 'T[K]'. +!!! error TS2322: Type 'undefined' is not assignable to type 'T[string]'. y[k] = x[k]; } @@ -134,6 +175,7 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS ~~~~ !!! error TS2322: Type 'U[keyof T] | undefined' is not assignable to type 'T[keyof T]'. !!! error TS2322: Type 'undefined' is not assignable to type 'T[keyof T]'. +!!! error TS2322: Type 'undefined' is not assignable to type 'T[string]'. y[k] = x[k]; // Error ~~~~ !!! error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T] | undefined'. @@ -141,7 +183,10 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS !!! error TS2322: Type 'T[string]' is not assignable to type 'U[keyof T]'. !!! error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T]'. !!! error TS2322: Type 'T[string]' is not assignable to type 'U[keyof T]'. -!!! error TS2322: Type 'T' is not assignable to type 'U'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[keyof T]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. } function f13(x: T, y: Partial, k: K) { @@ -149,6 +194,7 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS ~~~~ !!! error TS2322: Type 'U[K] | undefined' is not assignable to type 'T[K]'. !!! error TS2322: Type 'undefined' is not assignable to type 'T[K]'. +!!! error TS2322: Type 'undefined' is not assignable to type 'T[string]'. y[k] = x[k]; // Error ~~~~ !!! error TS2322: Type 'T[K]' is not assignable to type 'U[K] | undefined'. @@ -156,7 +202,10 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS !!! error TS2322: Type 'T[string]' is not assignable to type 'U[K]'. !!! error TS2322: Type 'T[K]' is not assignable to type 'U[K]'. !!! error TS2322: Type 'T[string]' is not assignable to type 'U[K]'. -!!! error TS2322: Type 'T' is not assignable to type 'U'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[K]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. } function f20(x: T, y: Readonly, k: keyof T) { @@ -270,7 +319,10 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS !!! error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'. !!! error TS2322: Type 'T[P]' is not assignable to type 'U[P]'. !!! error TS2322: Type 'T[string]' is not assignable to type 'U[P]'. -!!! error TS2322: Type 'T' is not assignable to type 'U'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[P]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. } function f72(x: { [P in keyof T]: T[P] }, y: { [P in keyof U]: U[P] }) { @@ -312,6 +364,9 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(167,5): error TS !!! error TS2322: Type '{ [P in K]: T[P]; }' is not assignable to type '{ [P in K]: U[P]; }'. !!! error TS2322: Type 'T[P]' is not assignable to type 'U[P]'. !!! error TS2322: Type 'T[string]' is not assignable to type 'U[P]'. -!!! error TS2322: Type 'T' is not assignable to type 'U'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[P]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T[string]' is not assignable to type 'U[string]'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. } \ No newline at end of file diff --git a/tests/baselines/reference/mappedTypeRelationships.js b/tests/baselines/reference/mappedTypeRelationships.js index 2476b72cef659..3580007137ea5 100644 --- a/tests/baselines/reference/mappedTypeRelationships.js +++ b/tests/baselines/reference/mappedTypeRelationships.js @@ -1,5 +1,4 @@ //// [mappedTypeRelationships.ts] - function f1(x: T, k: keyof T) { return x[k]; } diff --git a/tests/baselines/reference/mappedTypes1.js b/tests/baselines/reference/mappedTypes1.js index 4dd8f172179ad..67a7b8db9b261 100644 --- a/tests/baselines/reference/mappedTypes1.js +++ b/tests/baselines/reference/mappedTypes1.js @@ -1,5 +1,4 @@ //// [mappedTypes1.ts] - type Item = { a: string, b: number, c: boolean }; type T00 = { [P in "x" | "y"]: number }; diff --git a/tests/baselines/reference/mappedTypes1.symbols b/tests/baselines/reference/mappedTypes1.symbols index e8c09b2598951..e012b49ddf42a 100644 --- a/tests/baselines/reference/mappedTypes1.symbols +++ b/tests/baselines/reference/mappedTypes1.symbols @@ -1,165 +1,164 @@ === tests/cases/conformance/types/mapped/mappedTypes1.ts === - type Item = { a: string, b: number, c: boolean }; >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->a : Symbol(a, Decl(mappedTypes1.ts, 1, 13)) ->b : Symbol(b, Decl(mappedTypes1.ts, 1, 24)) ->c : Symbol(c, Decl(mappedTypes1.ts, 1, 35)) +>a : Symbol(a, Decl(mappedTypes1.ts, 0, 13)) +>b : Symbol(b, Decl(mappedTypes1.ts, 0, 24)) +>c : Symbol(c, Decl(mappedTypes1.ts, 0, 35)) type T00 = { [P in "x" | "y"]: number }; ->T00 : Symbol(T00, Decl(mappedTypes1.ts, 1, 49)) ->P : Symbol(P, Decl(mappedTypes1.ts, 3, 14)) +>T00 : Symbol(T00, Decl(mappedTypes1.ts, 0, 49)) +>P : Symbol(P, Decl(mappedTypes1.ts, 2, 14)) type T01 = { [P in "x" | "y"]: P }; ->T01 : Symbol(T01, Decl(mappedTypes1.ts, 3, 40)) ->P : Symbol(P, Decl(mappedTypes1.ts, 4, 14)) ->P : Symbol(P, Decl(mappedTypes1.ts, 4, 14)) +>T01 : Symbol(T01, Decl(mappedTypes1.ts, 2, 40)) +>P : Symbol(P, Decl(mappedTypes1.ts, 3, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 3, 14)) type T02 = { [P in "a" | "b"]: Item[P]; } ->T02 : Symbol(T02, Decl(mappedTypes1.ts, 4, 35)) ->P : Symbol(P, Decl(mappedTypes1.ts, 5, 14)) +>T02 : Symbol(T02, Decl(mappedTypes1.ts, 3, 35)) +>P : Symbol(P, Decl(mappedTypes1.ts, 4, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 5, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 4, 14)) type T03 = { [P in keyof Item]: Date }; ->T03 : Symbol(T03, Decl(mappedTypes1.ts, 5, 41)) ->P : Symbol(P, Decl(mappedTypes1.ts, 6, 14)) +>T03 : Symbol(T03, Decl(mappedTypes1.ts, 4, 41)) +>P : Symbol(P, Decl(mappedTypes1.ts, 5, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type T10 = { [P in keyof Item]: Item[P] }; ->T10 : Symbol(T10, Decl(mappedTypes1.ts, 6, 39)) ->P : Symbol(P, Decl(mappedTypes1.ts, 8, 14)) +>T10 : Symbol(T10, Decl(mappedTypes1.ts, 5, 39)) +>P : Symbol(P, Decl(mappedTypes1.ts, 7, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 8, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 7, 14)) type T11 = { [P in keyof Item]?: Item[P] }; ->T11 : Symbol(T11, Decl(mappedTypes1.ts, 8, 42)) ->P : Symbol(P, Decl(mappedTypes1.ts, 9, 14)) +>T11 : Symbol(T11, Decl(mappedTypes1.ts, 7, 42)) +>P : Symbol(P, Decl(mappedTypes1.ts, 8, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 9, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 8, 14)) type T12 = { readonly [P in keyof Item]: Item[P] }; ->T12 : Symbol(T12, Decl(mappedTypes1.ts, 9, 43)) ->P : Symbol(P, Decl(mappedTypes1.ts, 10, 23)) +>T12 : Symbol(T12, Decl(mappedTypes1.ts, 8, 43)) +>P : Symbol(P, Decl(mappedTypes1.ts, 9, 23)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 10, 23)) +>P : Symbol(P, Decl(mappedTypes1.ts, 9, 23)) type T13 = { readonly [P in keyof Item]?: Item[P] }; ->T13 : Symbol(T13, Decl(mappedTypes1.ts, 10, 51)) ->P : Symbol(P, Decl(mappedTypes1.ts, 11, 23)) +>T13 : Symbol(T13, Decl(mappedTypes1.ts, 9, 51)) +>P : Symbol(P, Decl(mappedTypes1.ts, 10, 23)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 11, 23)) +>P : Symbol(P, Decl(mappedTypes1.ts, 10, 23)) type T20 = { [P in keyof Item]: Item[P] | null }; ->T20 : Symbol(T20, Decl(mappedTypes1.ts, 11, 52)) ->P : Symbol(P, Decl(mappedTypes1.ts, 13, 14)) +>T20 : Symbol(T20, Decl(mappedTypes1.ts, 10, 52)) +>P : Symbol(P, Decl(mappedTypes1.ts, 12, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 13, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 12, 14)) type T21 = { [P in keyof Item]: Array }; ->T21 : Symbol(T21, Decl(mappedTypes1.ts, 13, 49)) ->P : Symbol(P, Decl(mappedTypes1.ts, 14, 14)) +>T21 : Symbol(T21, Decl(mappedTypes1.ts, 12, 49)) +>P : Symbol(P, Decl(mappedTypes1.ts, 13, 14)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes1.ts, 14, 14)) +>P : Symbol(P, Decl(mappedTypes1.ts, 13, 14)) type T30 = { [P in keyof any]: void }; ->T30 : Symbol(T30, Decl(mappedTypes1.ts, 14, 49)) ->P : Symbol(P, Decl(mappedTypes1.ts, 16, 14)) +>T30 : Symbol(T30, Decl(mappedTypes1.ts, 13, 49)) +>P : Symbol(P, Decl(mappedTypes1.ts, 15, 14)) type T31 = { [P in keyof string]: void }; ->T31 : Symbol(T31, Decl(mappedTypes1.ts, 16, 38)) ->P : Symbol(P, Decl(mappedTypes1.ts, 17, 14)) +>T31 : Symbol(T31, Decl(mappedTypes1.ts, 15, 38)) +>P : Symbol(P, Decl(mappedTypes1.ts, 16, 14)) type T32 = { [P in keyof number]: void }; ->T32 : Symbol(T32, Decl(mappedTypes1.ts, 17, 41)) ->P : Symbol(P, Decl(mappedTypes1.ts, 18, 14)) +>T32 : Symbol(T32, Decl(mappedTypes1.ts, 16, 41)) +>P : Symbol(P, Decl(mappedTypes1.ts, 17, 14)) type T33 = { [P in keyof boolean]: void }; ->T33 : Symbol(T33, Decl(mappedTypes1.ts, 18, 41)) ->P : Symbol(P, Decl(mappedTypes1.ts, 19, 14)) +>T33 : Symbol(T33, Decl(mappedTypes1.ts, 17, 41)) +>P : Symbol(P, Decl(mappedTypes1.ts, 18, 14)) type T34 = { [P in keyof undefined]: void }; ->T34 : Symbol(T34, Decl(mappedTypes1.ts, 19, 42)) ->P : Symbol(P, Decl(mappedTypes1.ts, 20, 14)) +>T34 : Symbol(T34, Decl(mappedTypes1.ts, 18, 42)) +>P : Symbol(P, Decl(mappedTypes1.ts, 19, 14)) type T35 = { [P in keyof null]: void }; ->T35 : Symbol(T35, Decl(mappedTypes1.ts, 20, 44)) ->P : Symbol(P, Decl(mappedTypes1.ts, 21, 14)) +>T35 : Symbol(T35, Decl(mappedTypes1.ts, 19, 44)) +>P : Symbol(P, Decl(mappedTypes1.ts, 20, 14)) type T36 = { [P in keyof void]: void }; ->T36 : Symbol(T36, Decl(mappedTypes1.ts, 21, 39)) ->P : Symbol(P, Decl(mappedTypes1.ts, 22, 14)) +>T36 : Symbol(T36, Decl(mappedTypes1.ts, 20, 39)) +>P : Symbol(P, Decl(mappedTypes1.ts, 21, 14)) type T37 = { [P in keyof symbol]: void }; ->T37 : Symbol(T37, Decl(mappedTypes1.ts, 22, 39)) ->P : Symbol(P, Decl(mappedTypes1.ts, 23, 14)) +>T37 : Symbol(T37, Decl(mappedTypes1.ts, 21, 39)) +>P : Symbol(P, Decl(mappedTypes1.ts, 22, 14)) type T38 = { [P in keyof never]: void }; ->T38 : Symbol(T38, Decl(mappedTypes1.ts, 23, 41)) ->P : Symbol(P, Decl(mappedTypes1.ts, 24, 14)) +>T38 : Symbol(T38, Decl(mappedTypes1.ts, 22, 41)) +>P : Symbol(P, Decl(mappedTypes1.ts, 23, 14)) type T40 = { [P in string]: void }; ->T40 : Symbol(T40, Decl(mappedTypes1.ts, 24, 40)) ->P : Symbol(P, Decl(mappedTypes1.ts, 26, 14)) +>T40 : Symbol(T40, Decl(mappedTypes1.ts, 23, 40)) +>P : Symbol(P, Decl(mappedTypes1.ts, 25, 14)) type T43 = { [P in "a" | "b"]: void }; ->T43 : Symbol(T43, Decl(mappedTypes1.ts, 26, 35)) ->P : Symbol(P, Decl(mappedTypes1.ts, 27, 14)) +>T43 : Symbol(T43, Decl(mappedTypes1.ts, 25, 35)) +>P : Symbol(P, Decl(mappedTypes1.ts, 26, 14)) type T44 = { [P in "a" | "b" | "0" | "1"]: void }; ->T44 : Symbol(T44, Decl(mappedTypes1.ts, 27, 38)) ->P : Symbol(P, Decl(mappedTypes1.ts, 28, 14)) +>T44 : Symbol(T44, Decl(mappedTypes1.ts, 26, 38)) +>P : Symbol(P, Decl(mappedTypes1.ts, 27, 14)) type T47 = { [P in string | "a" | "b" | "0" | "1"]: void }; ->T47 : Symbol(T47, Decl(mappedTypes1.ts, 28, 50)) ->P : Symbol(P, Decl(mappedTypes1.ts, 29, 14)) +>T47 : Symbol(T47, Decl(mappedTypes1.ts, 27, 50)) +>P : Symbol(P, Decl(mappedTypes1.ts, 28, 14)) declare function f1(): { [P in keyof T1]: void }; ->f1 : Symbol(f1, Decl(mappedTypes1.ts, 29, 59)) +>f1 : Symbol(f1, Decl(mappedTypes1.ts, 28, 59)) +>T1 : Symbol(T1, Decl(mappedTypes1.ts, 30, 20)) +>P : Symbol(P, Decl(mappedTypes1.ts, 30, 30)) +>T1 : Symbol(T1, Decl(mappedTypes1.ts, 30, 20)) + +declare function f2(): { [P in keyof T1]: void }; +>f2 : Symbol(f2, Decl(mappedTypes1.ts, 30, 53)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 31, 20)) ->P : Symbol(P, Decl(mappedTypes1.ts, 31, 30)) +>P : Symbol(P, Decl(mappedTypes1.ts, 31, 45)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 31, 20)) -declare function f2(): { [P in keyof T1]: void }; ->f2 : Symbol(f2, Decl(mappedTypes1.ts, 31, 53)) +declare function f3(): { [P in keyof T1]: void }; +>f3 : Symbol(f3, Decl(mappedTypes1.ts, 31, 68)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 32, 20)) >P : Symbol(P, Decl(mappedTypes1.ts, 32, 45)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 32, 20)) -declare function f3(): { [P in keyof T1]: void }; ->f3 : Symbol(f3, Decl(mappedTypes1.ts, 32, 68)) +declare function f4(): { [P in keyof T1]: void }; +>f4 : Symbol(f4, Decl(mappedTypes1.ts, 32, 68)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 33, 20)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >P : Symbol(P, Decl(mappedTypes1.ts, 33, 45)) >T1 : Symbol(T1, Decl(mappedTypes1.ts, 33, 20)) -declare function f4(): { [P in keyof T1]: void }; ->f4 : Symbol(f4, Decl(mappedTypes1.ts, 33, 68)) ->T1 : Symbol(T1, Decl(mappedTypes1.ts, 34, 20)) ->Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->P : Symbol(P, Decl(mappedTypes1.ts, 34, 45)) ->T1 : Symbol(T1, Decl(mappedTypes1.ts, 34, 20)) - let x1 = f1(); ->x1 : Symbol(x1, Decl(mappedTypes1.ts, 36, 3)) ->f1 : Symbol(f1, Decl(mappedTypes1.ts, 29, 59)) +>x1 : Symbol(x1, Decl(mappedTypes1.ts, 35, 3)) +>f1 : Symbol(f1, Decl(mappedTypes1.ts, 28, 59)) let x2 = f2(); ->x2 : Symbol(x2, Decl(mappedTypes1.ts, 37, 3)) ->f2 : Symbol(f2, Decl(mappedTypes1.ts, 31, 53)) +>x2 : Symbol(x2, Decl(mappedTypes1.ts, 36, 3)) +>f2 : Symbol(f2, Decl(mappedTypes1.ts, 30, 53)) let x3 = f3(); ->x3 : Symbol(x3, Decl(mappedTypes1.ts, 38, 3)) ->f3 : Symbol(f3, Decl(mappedTypes1.ts, 32, 68)) +>x3 : Symbol(x3, Decl(mappedTypes1.ts, 37, 3)) +>f3 : Symbol(f3, Decl(mappedTypes1.ts, 31, 68)) let x4 = f4(); ->x4 : Symbol(x4, Decl(mappedTypes1.ts, 39, 3)) ->f4 : Symbol(f4, Decl(mappedTypes1.ts, 33, 68)) +>x4 : Symbol(x4, Decl(mappedTypes1.ts, 38, 3)) +>f4 : Symbol(f4, Decl(mappedTypes1.ts, 32, 68)) diff --git a/tests/baselines/reference/mappedTypes1.types b/tests/baselines/reference/mappedTypes1.types index a9a7f53a89931..66aae568364f9 100644 --- a/tests/baselines/reference/mappedTypes1.types +++ b/tests/baselines/reference/mappedTypes1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypes1.ts === - type Item = { a: string, b: number, c: boolean }; >Item : Item >a : string diff --git a/tests/baselines/reference/mappedTypes2.js b/tests/baselines/reference/mappedTypes2.js index 84d052b628737..4122cf575c600 100644 --- a/tests/baselines/reference/mappedTypes2.js +++ b/tests/baselines/reference/mappedTypes2.js @@ -1,5 +1,4 @@ //// [mappedTypes2.ts] - function verifyLibTypes() { var x1: Partial; var x1: { [P in keyof T]?: T[P] }; diff --git a/tests/baselines/reference/mappedTypes2.symbols b/tests/baselines/reference/mappedTypes2.symbols index 079a56243c5a2..7d9727daedd08 100644 --- a/tests/baselines/reference/mappedTypes2.symbols +++ b/tests/baselines/reference/mappedTypes2.symbols @@ -1,353 +1,352 @@ === tests/cases/conformance/types/mapped/mappedTypes2.ts === - function verifyLibTypes() { >verifyLibTypes : Symbol(verifyLibTypes, Decl(mappedTypes2.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->U : Symbol(U, Decl(mappedTypes2.ts, 1, 45)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>U : Symbol(U, Decl(mappedTypes2.ts, 0, 45)) var x1: Partial; ->x1 : Symbol(x1, Decl(mappedTypes2.ts, 2, 7), Decl(mappedTypes2.ts, 3, 7)) +>x1 : Symbol(x1, Decl(mappedTypes2.ts, 1, 7), Decl(mappedTypes2.ts, 2, 7)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) var x1: { [P in keyof T]?: T[P] }; ->x1 : Symbol(x1, Decl(mappedTypes2.ts, 2, 7), Decl(mappedTypes2.ts, 3, 7)) ->P : Symbol(P, Decl(mappedTypes2.ts, 3, 15)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->P : Symbol(P, Decl(mappedTypes2.ts, 3, 15)) +>x1 : Symbol(x1, Decl(mappedTypes2.ts, 1, 7), Decl(mappedTypes2.ts, 2, 7)) +>P : Symbol(P, Decl(mappedTypes2.ts, 2, 15)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>P : Symbol(P, Decl(mappedTypes2.ts, 2, 15)) var x2: Readonly; ->x2 : Symbol(x2, Decl(mappedTypes2.ts, 4, 7), Decl(mappedTypes2.ts, 5, 7)) +>x2 : Symbol(x2, Decl(mappedTypes2.ts, 3, 7), Decl(mappedTypes2.ts, 4, 7)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) var x2: { readonly [P in keyof T]: T[P] }; ->x2 : Symbol(x2, Decl(mappedTypes2.ts, 4, 7), Decl(mappedTypes2.ts, 5, 7)) ->P : Symbol(P, Decl(mappedTypes2.ts, 5, 24)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->P : Symbol(P, Decl(mappedTypes2.ts, 5, 24)) +>x2 : Symbol(x2, Decl(mappedTypes2.ts, 3, 7), Decl(mappedTypes2.ts, 4, 7)) +>P : Symbol(P, Decl(mappedTypes2.ts, 4, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>P : Symbol(P, Decl(mappedTypes2.ts, 4, 24)) var x3: Pick; ->x3 : Symbol(x3, Decl(mappedTypes2.ts, 6, 7), Decl(mappedTypes2.ts, 7, 7)) +>x3 : Symbol(x3, Decl(mappedTypes2.ts, 5, 7), Decl(mappedTypes2.ts, 6, 7)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) var x3: { [P in K]: T[P] }; ->x3 : Symbol(x3, Decl(mappedTypes2.ts, 6, 7), Decl(mappedTypes2.ts, 7, 7)) ->P : Symbol(P, Decl(mappedTypes2.ts, 7, 15)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) ->T : Symbol(T, Decl(mappedTypes2.ts, 1, 24)) ->P : Symbol(P, Decl(mappedTypes2.ts, 7, 15)) +>x3 : Symbol(x3, Decl(mappedTypes2.ts, 5, 7), Decl(mappedTypes2.ts, 6, 7)) +>P : Symbol(P, Decl(mappedTypes2.ts, 6, 15)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) +>T : Symbol(T, Decl(mappedTypes2.ts, 0, 24)) +>P : Symbol(P, Decl(mappedTypes2.ts, 6, 15)) var x4: Record; ->x4 : Symbol(x4, Decl(mappedTypes2.ts, 8, 7), Decl(mappedTypes2.ts, 9, 7)) +>x4 : Symbol(x4, Decl(mappedTypes2.ts, 7, 7), Decl(mappedTypes2.ts, 8, 7)) >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) ->U : Symbol(U, Decl(mappedTypes2.ts, 1, 45)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) +>U : Symbol(U, Decl(mappedTypes2.ts, 0, 45)) var x4: { [P in K]: U }; ->x4 : Symbol(x4, Decl(mappedTypes2.ts, 8, 7), Decl(mappedTypes2.ts, 9, 7)) ->P : Symbol(P, Decl(mappedTypes2.ts, 9, 15)) ->K : Symbol(K, Decl(mappedTypes2.ts, 1, 26)) ->U : Symbol(U, Decl(mappedTypes2.ts, 1, 45)) +>x4 : Symbol(x4, Decl(mappedTypes2.ts, 7, 7), Decl(mappedTypes2.ts, 8, 7)) +>P : Symbol(P, Decl(mappedTypes2.ts, 8, 15)) +>K : Symbol(K, Decl(mappedTypes2.ts, 0, 26)) +>U : Symbol(U, Decl(mappedTypes2.ts, 0, 45)) } type Proxy = { ->Proxy : Symbol(Proxy, Decl(mappedTypes2.ts, 10, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 12, 11)) +>Proxy : Symbol(Proxy, Decl(mappedTypes2.ts, 9, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 11, 11)) get(): T; ->get : Symbol(get, Decl(mappedTypes2.ts, 12, 17)) ->T : Symbol(T, Decl(mappedTypes2.ts, 12, 11)) +>get : Symbol(get, Decl(mappedTypes2.ts, 11, 17)) +>T : Symbol(T, Decl(mappedTypes2.ts, 11, 11)) set(value: T): void; ->set : Symbol(set, Decl(mappedTypes2.ts, 13, 13)) ->value : Symbol(value, Decl(mappedTypes2.ts, 14, 8)) ->T : Symbol(T, Decl(mappedTypes2.ts, 12, 11)) +>set : Symbol(set, Decl(mappedTypes2.ts, 12, 13)) +>value : Symbol(value, Decl(mappedTypes2.ts, 13, 8)) +>T : Symbol(T, Decl(mappedTypes2.ts, 11, 11)) } type Proxify = { ->Proxify : Symbol(Proxify, Decl(mappedTypes2.ts, 15, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 17, 13)) +>Proxify : Symbol(Proxify, Decl(mappedTypes2.ts, 14, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 16, 13)) [P in keyof T]: Proxy; ->P : Symbol(P, Decl(mappedTypes2.ts, 18, 5)) ->T : Symbol(T, Decl(mappedTypes2.ts, 17, 13)) ->Proxy : Symbol(Proxy, Decl(mappedTypes2.ts, 10, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 17, 13)) ->P : Symbol(P, Decl(mappedTypes2.ts, 18, 5)) +>P : Symbol(P, Decl(mappedTypes2.ts, 17, 5)) +>T : Symbol(T, Decl(mappedTypes2.ts, 16, 13)) +>Proxy : Symbol(Proxy, Decl(mappedTypes2.ts, 9, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 16, 13)) +>P : Symbol(P, Decl(mappedTypes2.ts, 17, 5)) } type DeepReadonly = { ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 19, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 21, 18)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 18, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 20, 18)) readonly [P in keyof T]: DeepReadonly; ->P : Symbol(P, Decl(mappedTypes2.ts, 22, 14)) ->T : Symbol(T, Decl(mappedTypes2.ts, 21, 18)) ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 19, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 21, 18)) ->P : Symbol(P, Decl(mappedTypes2.ts, 22, 14)) +>P : Symbol(P, Decl(mappedTypes2.ts, 21, 14)) +>T : Symbol(T, Decl(mappedTypes2.ts, 20, 18)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 18, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 20, 18)) +>P : Symbol(P, Decl(mappedTypes2.ts, 21, 14)) }; declare function assign(obj: T, props: Partial): void; ->assign : Symbol(assign, Decl(mappedTypes2.ts, 23, 2)) ->T : Symbol(T, Decl(mappedTypes2.ts, 25, 24)) ->obj : Symbol(obj, Decl(mappedTypes2.ts, 25, 27)) ->T : Symbol(T, Decl(mappedTypes2.ts, 25, 24)) ->props : Symbol(props, Decl(mappedTypes2.ts, 25, 34)) +>assign : Symbol(assign, Decl(mappedTypes2.ts, 22, 2)) +>T : Symbol(T, Decl(mappedTypes2.ts, 24, 24)) +>obj : Symbol(obj, Decl(mappedTypes2.ts, 24, 27)) +>T : Symbol(T, Decl(mappedTypes2.ts, 24, 24)) +>props : Symbol(props, Decl(mappedTypes2.ts, 24, 34)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 25, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 24, 24)) declare function freeze(obj: T): Readonly; ->freeze : Symbol(freeze, Decl(mappedTypes2.ts, 25, 60)) ->T : Symbol(T, Decl(mappedTypes2.ts, 26, 24)) ->obj : Symbol(obj, Decl(mappedTypes2.ts, 26, 27)) ->T : Symbol(T, Decl(mappedTypes2.ts, 26, 24)) +>freeze : Symbol(freeze, Decl(mappedTypes2.ts, 24, 60)) +>T : Symbol(T, Decl(mappedTypes2.ts, 25, 24)) +>obj : Symbol(obj, Decl(mappedTypes2.ts, 25, 27)) +>T : Symbol(T, Decl(mappedTypes2.ts, 25, 24)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 26, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 25, 24)) declare function pick(obj: T, ...keys: K[]): Pick; ->pick : Symbol(pick, Decl(mappedTypes2.ts, 26, 48)) ->T : Symbol(T, Decl(mappedTypes2.ts, 27, 22)) ->K : Symbol(K, Decl(mappedTypes2.ts, 27, 24)) ->T : Symbol(T, Decl(mappedTypes2.ts, 27, 22)) ->obj : Symbol(obj, Decl(mappedTypes2.ts, 27, 44)) ->T : Symbol(T, Decl(mappedTypes2.ts, 27, 22)) ->keys : Symbol(keys, Decl(mappedTypes2.ts, 27, 51)) ->K : Symbol(K, Decl(mappedTypes2.ts, 27, 24)) +>pick : Symbol(pick, Decl(mappedTypes2.ts, 25, 48)) +>T : Symbol(T, Decl(mappedTypes2.ts, 26, 22)) +>K : Symbol(K, Decl(mappedTypes2.ts, 26, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 26, 22)) +>obj : Symbol(obj, Decl(mappedTypes2.ts, 26, 44)) +>T : Symbol(T, Decl(mappedTypes2.ts, 26, 22)) +>keys : Symbol(keys, Decl(mappedTypes2.ts, 26, 51)) +>K : Symbol(K, Decl(mappedTypes2.ts, 26, 24)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypes2.ts, 27, 22)) ->K : Symbol(K, Decl(mappedTypes2.ts, 27, 24)) +>T : Symbol(T, Decl(mappedTypes2.ts, 26, 22)) +>K : Symbol(K, Decl(mappedTypes2.ts, 26, 24)) declare function mapObject(obj: Record, f: (x: T) => U): Record; ->mapObject : Symbol(mapObject, Decl(mappedTypes2.ts, 27, 78)) ->K : Symbol(K, Decl(mappedTypes2.ts, 28, 27)) ->T : Symbol(T, Decl(mappedTypes2.ts, 28, 44)) ->U : Symbol(U, Decl(mappedTypes2.ts, 28, 47)) ->obj : Symbol(obj, Decl(mappedTypes2.ts, 28, 51)) +>mapObject : Symbol(mapObject, Decl(mappedTypes2.ts, 26, 78)) +>K : Symbol(K, Decl(mappedTypes2.ts, 27, 27)) +>T : Symbol(T, Decl(mappedTypes2.ts, 27, 44)) +>U : Symbol(U, Decl(mappedTypes2.ts, 27, 47)) +>obj : Symbol(obj, Decl(mappedTypes2.ts, 27, 51)) >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(mappedTypes2.ts, 28, 27)) ->T : Symbol(T, Decl(mappedTypes2.ts, 28, 44)) ->f : Symbol(f, Decl(mappedTypes2.ts, 28, 69)) ->x : Symbol(x, Decl(mappedTypes2.ts, 28, 74)) ->T : Symbol(T, Decl(mappedTypes2.ts, 28, 44)) ->U : Symbol(U, Decl(mappedTypes2.ts, 28, 47)) +>K : Symbol(K, Decl(mappedTypes2.ts, 27, 27)) +>T : Symbol(T, Decl(mappedTypes2.ts, 27, 44)) +>f : Symbol(f, Decl(mappedTypes2.ts, 27, 69)) +>x : Symbol(x, Decl(mappedTypes2.ts, 27, 74)) +>T : Symbol(T, Decl(mappedTypes2.ts, 27, 44)) +>U : Symbol(U, Decl(mappedTypes2.ts, 27, 47)) >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(mappedTypes2.ts, 28, 27)) ->U : Symbol(U, Decl(mappedTypes2.ts, 28, 47)) +>K : Symbol(K, Decl(mappedTypes2.ts, 27, 27)) +>U : Symbol(U, Decl(mappedTypes2.ts, 27, 47)) declare function proxify(obj: T): Proxify; ->proxify : Symbol(proxify, Decl(mappedTypes2.ts, 28, 100)) ->T : Symbol(T, Decl(mappedTypes2.ts, 29, 25)) ->obj : Symbol(obj, Decl(mappedTypes2.ts, 29, 28)) ->T : Symbol(T, Decl(mappedTypes2.ts, 29, 25)) ->Proxify : Symbol(Proxify, Decl(mappedTypes2.ts, 15, 1)) ->T : Symbol(T, Decl(mappedTypes2.ts, 29, 25)) +>proxify : Symbol(proxify, Decl(mappedTypes2.ts, 27, 100)) +>T : Symbol(T, Decl(mappedTypes2.ts, 28, 25)) +>obj : Symbol(obj, Decl(mappedTypes2.ts, 28, 28)) +>T : Symbol(T, Decl(mappedTypes2.ts, 28, 25)) +>Proxify : Symbol(Proxify, Decl(mappedTypes2.ts, 14, 1)) +>T : Symbol(T, Decl(mappedTypes2.ts, 28, 25)) interface Point { ->Point : Symbol(Point, Decl(mappedTypes2.ts, 29, 48)) +>Point : Symbol(Point, Decl(mappedTypes2.ts, 28, 48)) x: number; ->x : Symbol(Point.x, Decl(mappedTypes2.ts, 31, 17)) +>x : Symbol(Point.x, Decl(mappedTypes2.ts, 30, 17)) y: number; ->y : Symbol(Point.y, Decl(mappedTypes2.ts, 32, 14)) +>y : Symbol(Point.y, Decl(mappedTypes2.ts, 31, 14)) } interface Shape { ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) name: string; ->name : Symbol(Shape.name, Decl(mappedTypes2.ts, 36, 17)) +>name : Symbol(Shape.name, Decl(mappedTypes2.ts, 35, 17)) width: number; ->width : Symbol(Shape.width, Decl(mappedTypes2.ts, 37, 17)) +>width : Symbol(Shape.width, Decl(mappedTypes2.ts, 36, 17)) height: number; ->height : Symbol(Shape.height, Decl(mappedTypes2.ts, 38, 18)) +>height : Symbol(Shape.height, Decl(mappedTypes2.ts, 37, 18)) location: Point; ->location : Symbol(Shape.location, Decl(mappedTypes2.ts, 39, 19)) ->Point : Symbol(Point, Decl(mappedTypes2.ts, 29, 48)) +>location : Symbol(Shape.location, Decl(mappedTypes2.ts, 38, 19)) +>Point : Symbol(Point, Decl(mappedTypes2.ts, 28, 48)) } interface PartialShape { ->PartialShape : Symbol(PartialShape, Decl(mappedTypes2.ts, 41, 1)) +>PartialShape : Symbol(PartialShape, Decl(mappedTypes2.ts, 40, 1)) name?: string; ->name : Symbol(PartialShape.name, Decl(mappedTypes2.ts, 43, 24)) +>name : Symbol(PartialShape.name, Decl(mappedTypes2.ts, 42, 24)) width?: number; ->width : Symbol(PartialShape.width, Decl(mappedTypes2.ts, 44, 18)) +>width : Symbol(PartialShape.width, Decl(mappedTypes2.ts, 43, 18)) height?: number; ->height : Symbol(PartialShape.height, Decl(mappedTypes2.ts, 45, 19)) +>height : Symbol(PartialShape.height, Decl(mappedTypes2.ts, 44, 19)) location?: Point; ->location : Symbol(PartialShape.location, Decl(mappedTypes2.ts, 46, 20)) ->Point : Symbol(Point, Decl(mappedTypes2.ts, 29, 48)) +>location : Symbol(PartialShape.location, Decl(mappedTypes2.ts, 45, 20)) +>Point : Symbol(Point, Decl(mappedTypes2.ts, 28, 48)) } interface ReadonlyShape { ->ReadonlyShape : Symbol(ReadonlyShape, Decl(mappedTypes2.ts, 48, 1)) +>ReadonlyShape : Symbol(ReadonlyShape, Decl(mappedTypes2.ts, 47, 1)) readonly name: string; ->name : Symbol(ReadonlyShape.name, Decl(mappedTypes2.ts, 50, 25)) +>name : Symbol(ReadonlyShape.name, Decl(mappedTypes2.ts, 49, 25)) readonly width: number; ->width : Symbol(ReadonlyShape.width, Decl(mappedTypes2.ts, 51, 26)) +>width : Symbol(ReadonlyShape.width, Decl(mappedTypes2.ts, 50, 26)) readonly height: number; ->height : Symbol(ReadonlyShape.height, Decl(mappedTypes2.ts, 52, 27)) +>height : Symbol(ReadonlyShape.height, Decl(mappedTypes2.ts, 51, 27)) readonly location: Point; ->location : Symbol(ReadonlyShape.location, Decl(mappedTypes2.ts, 53, 28)) ->Point : Symbol(Point, Decl(mappedTypes2.ts, 29, 48)) +>location : Symbol(ReadonlyShape.location, Decl(mappedTypes2.ts, 52, 28)) +>Point : Symbol(Point, Decl(mappedTypes2.ts, 28, 48)) } function f0(s1: Shape, s2: Shape) { ->f0 : Symbol(f0, Decl(mappedTypes2.ts, 55, 1)) ->s1 : Symbol(s1, Decl(mappedTypes2.ts, 57, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) ->s2 : Symbol(s2, Decl(mappedTypes2.ts, 57, 22)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f0 : Symbol(f0, Decl(mappedTypes2.ts, 54, 1)) +>s1 : Symbol(s1, Decl(mappedTypes2.ts, 56, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) +>s2 : Symbol(s2, Decl(mappedTypes2.ts, 56, 22)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) assign(s1, { name: "circle" }); ->assign : Symbol(assign, Decl(mappedTypes2.ts, 23, 2)) ->s1 : Symbol(s1, Decl(mappedTypes2.ts, 57, 12)) ->name : Symbol(name, Decl(mappedTypes2.ts, 58, 16)) +>assign : Symbol(assign, Decl(mappedTypes2.ts, 22, 2)) +>s1 : Symbol(s1, Decl(mappedTypes2.ts, 56, 12)) +>name : Symbol(name, Decl(mappedTypes2.ts, 57, 16)) assign(s2, { width: 10, height: 20 }); ->assign : Symbol(assign, Decl(mappedTypes2.ts, 23, 2)) ->s2 : Symbol(s2, Decl(mappedTypes2.ts, 57, 22)) ->width : Symbol(width, Decl(mappedTypes2.ts, 59, 16)) ->height : Symbol(height, Decl(mappedTypes2.ts, 59, 27)) +>assign : Symbol(assign, Decl(mappedTypes2.ts, 22, 2)) +>s2 : Symbol(s2, Decl(mappedTypes2.ts, 56, 22)) +>width : Symbol(width, Decl(mappedTypes2.ts, 58, 16)) +>height : Symbol(height, Decl(mappedTypes2.ts, 58, 27)) } function f1(shape: Shape) { ->f1 : Symbol(f1, Decl(mappedTypes2.ts, 60, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 62, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f1 : Symbol(f1, Decl(mappedTypes2.ts, 59, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 61, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) var frozen: ReadonlyShape; ->frozen : Symbol(frozen, Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7), Decl(mappedTypes2.ts, 65, 7)) ->ReadonlyShape : Symbol(ReadonlyShape, Decl(mappedTypes2.ts, 48, 1)) +>frozen : Symbol(frozen, Decl(mappedTypes2.ts, 62, 7), Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7)) +>ReadonlyShape : Symbol(ReadonlyShape, Decl(mappedTypes2.ts, 47, 1)) var frozen: Readonly; ->frozen : Symbol(frozen, Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7), Decl(mappedTypes2.ts, 65, 7)) +>frozen : Symbol(frozen, Decl(mappedTypes2.ts, 62, 7), Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) var frozen = freeze(shape); ->frozen : Symbol(frozen, Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7), Decl(mappedTypes2.ts, 65, 7)) ->freeze : Symbol(freeze, Decl(mappedTypes2.ts, 25, 60)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 62, 12)) +>frozen : Symbol(frozen, Decl(mappedTypes2.ts, 62, 7), Decl(mappedTypes2.ts, 63, 7), Decl(mappedTypes2.ts, 64, 7)) +>freeze : Symbol(freeze, Decl(mappedTypes2.ts, 24, 60)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 61, 12)) } function f2(shape: Shape) { ->f2 : Symbol(f2, Decl(mappedTypes2.ts, 66, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 68, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f2 : Symbol(f2, Decl(mappedTypes2.ts, 65, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 67, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) var partial: PartialShape; ->partial : Symbol(partial, Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7), Decl(mappedTypes2.ts, 71, 7)) ->PartialShape : Symbol(PartialShape, Decl(mappedTypes2.ts, 41, 1)) +>partial : Symbol(partial, Decl(mappedTypes2.ts, 68, 7), Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7)) +>PartialShape : Symbol(PartialShape, Decl(mappedTypes2.ts, 40, 1)) var partial: Partial; ->partial : Symbol(partial, Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7), Decl(mappedTypes2.ts, 71, 7)) +>partial : Symbol(partial, Decl(mappedTypes2.ts, 68, 7), Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) var partial: Partial = {}; ->partial : Symbol(partial, Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7), Decl(mappedTypes2.ts, 71, 7)) +>partial : Symbol(partial, Decl(mappedTypes2.ts, 68, 7), Decl(mappedTypes2.ts, 69, 7), Decl(mappedTypes2.ts, 70, 7)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) } function f3(shape: Shape) { ->f3 : Symbol(f3, Decl(mappedTypes2.ts, 72, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 74, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f3 : Symbol(f3, Decl(mappedTypes2.ts, 71, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 73, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) const x = pick(shape, "name", "location"); // { name: string, location: Point } ->x : Symbol(x, Decl(mappedTypes2.ts, 75, 9)) ->pick : Symbol(pick, Decl(mappedTypes2.ts, 26, 48)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 74, 12)) +>x : Symbol(x, Decl(mappedTypes2.ts, 74, 9)) +>pick : Symbol(pick, Decl(mappedTypes2.ts, 25, 48)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 73, 12)) } function f4() { ->f4 : Symbol(f4, Decl(mappedTypes2.ts, 76, 1)) +>f4 : Symbol(f4, Decl(mappedTypes2.ts, 75, 1)) const rec = { foo: "hello", bar: "world", baz: "bye" }; ->rec : Symbol(rec, Decl(mappedTypes2.ts, 79, 9)) ->foo : Symbol(foo, Decl(mappedTypes2.ts, 79, 17)) ->bar : Symbol(bar, Decl(mappedTypes2.ts, 79, 31)) ->baz : Symbol(baz, Decl(mappedTypes2.ts, 79, 45)) +>rec : Symbol(rec, Decl(mappedTypes2.ts, 78, 9)) +>foo : Symbol(foo, Decl(mappedTypes2.ts, 78, 17)) +>bar : Symbol(bar, Decl(mappedTypes2.ts, 78, 31)) +>baz : Symbol(baz, Decl(mappedTypes2.ts, 78, 45)) const lengths = mapObject(rec, s => s.length); // { foo: number, bar: number, baz: number } ->lengths : Symbol(lengths, Decl(mappedTypes2.ts, 80, 9)) ->mapObject : Symbol(mapObject, Decl(mappedTypes2.ts, 27, 78)) ->rec : Symbol(rec, Decl(mappedTypes2.ts, 79, 9)) ->s : Symbol(s, Decl(mappedTypes2.ts, 80, 34)) +>lengths : Symbol(lengths, Decl(mappedTypes2.ts, 79, 9)) +>mapObject : Symbol(mapObject, Decl(mappedTypes2.ts, 26, 78)) +>rec : Symbol(rec, Decl(mappedTypes2.ts, 78, 9)) +>s : Symbol(s, Decl(mappedTypes2.ts, 79, 34)) >s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->s : Symbol(s, Decl(mappedTypes2.ts, 80, 34)) +>s : Symbol(s, Decl(mappedTypes2.ts, 79, 34)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } function f5(shape: Shape) { ->f5 : Symbol(f5, Decl(mappedTypes2.ts, 81, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 83, 12)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f5 : Symbol(f5, Decl(mappedTypes2.ts, 80, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 82, 12)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) const p = proxify(shape); ->p : Symbol(p, Decl(mappedTypes2.ts, 84, 9)) ->proxify : Symbol(proxify, Decl(mappedTypes2.ts, 28, 100)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 83, 12)) +>p : Symbol(p, Decl(mappedTypes2.ts, 83, 9)) +>proxify : Symbol(proxify, Decl(mappedTypes2.ts, 27, 100)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 82, 12)) let name = p.name.get(); ->name : Symbol(name, Decl(mappedTypes2.ts, 85, 7)) ->p.name.get : Symbol(get, Decl(mappedTypes2.ts, 12, 17)) +>name : Symbol(name, Decl(mappedTypes2.ts, 84, 7)) +>p.name.get : Symbol(get, Decl(mappedTypes2.ts, 11, 17)) >p.name : Symbol(name) ->p : Symbol(p, Decl(mappedTypes2.ts, 84, 9)) +>p : Symbol(p, Decl(mappedTypes2.ts, 83, 9)) >name : Symbol(name) ->get : Symbol(get, Decl(mappedTypes2.ts, 12, 17)) +>get : Symbol(get, Decl(mappedTypes2.ts, 11, 17)) p.width.set(42); ->p.width.set : Symbol(set, Decl(mappedTypes2.ts, 13, 13)) +>p.width.set : Symbol(set, Decl(mappedTypes2.ts, 12, 13)) >p.width : Symbol(width) ->p : Symbol(p, Decl(mappedTypes2.ts, 84, 9)) +>p : Symbol(p, Decl(mappedTypes2.ts, 83, 9)) >width : Symbol(width) ->set : Symbol(set, Decl(mappedTypes2.ts, 13, 13)) +>set : Symbol(set, Decl(mappedTypes2.ts, 12, 13)) } function f6(shape: DeepReadonly) { ->f6 : Symbol(f6, Decl(mappedTypes2.ts, 87, 1)) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 89, 12)) ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 19, 1)) ->Shape : Symbol(Shape, Decl(mappedTypes2.ts, 34, 1)) +>f6 : Symbol(f6, Decl(mappedTypes2.ts, 86, 1)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 88, 12)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes2.ts, 18, 1)) +>Shape : Symbol(Shape, Decl(mappedTypes2.ts, 33, 1)) let name = shape.name; // string ->name : Symbol(name, Decl(mappedTypes2.ts, 90, 7)) +>name : Symbol(name, Decl(mappedTypes2.ts, 89, 7)) >shape.name : Symbol(name) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 89, 12)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 88, 12)) >name : Symbol(name) let location = shape.location; // DeepReadonly ->location : Symbol(location, Decl(mappedTypes2.ts, 91, 7)) +>location : Symbol(location, Decl(mappedTypes2.ts, 90, 7)) >shape.location : Symbol(location) ->shape : Symbol(shape, Decl(mappedTypes2.ts, 89, 12)) +>shape : Symbol(shape, Decl(mappedTypes2.ts, 88, 12)) >location : Symbol(location) let x = location.x; // number ->x : Symbol(x, Decl(mappedTypes2.ts, 92, 7)) +>x : Symbol(x, Decl(mappedTypes2.ts, 91, 7)) >location.x : Symbol(x) ->location : Symbol(location, Decl(mappedTypes2.ts, 91, 7)) +>location : Symbol(location, Decl(mappedTypes2.ts, 90, 7)) >x : Symbol(x) } diff --git a/tests/baselines/reference/mappedTypes2.types b/tests/baselines/reference/mappedTypes2.types index f082069f569be..7c54fffcb08d0 100644 --- a/tests/baselines/reference/mappedTypes2.types +++ b/tests/baselines/reference/mappedTypes2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypes2.ts === - function verifyLibTypes() { >verifyLibTypes : () => void >T : T diff --git a/tests/baselines/reference/mappedTypes3.js b/tests/baselines/reference/mappedTypes3.js index 712822e872888..b839e02d3a361 100644 --- a/tests/baselines/reference/mappedTypes3.js +++ b/tests/baselines/reference/mappedTypes3.js @@ -1,5 +1,4 @@ //// [mappedTypes3.ts] - class Box

{ value: P; } diff --git a/tests/baselines/reference/mappedTypes3.symbols b/tests/baselines/reference/mappedTypes3.symbols index 3d909c8e532a1..683c764f0f44b 100644 --- a/tests/baselines/reference/mappedTypes3.symbols +++ b/tests/baselines/reference/mappedTypes3.symbols @@ -1,135 +1,134 @@ === tests/cases/conformance/types/mapped/mappedTypes3.ts === - class Box

{ >Box : Symbol(Box, Decl(mappedTypes3.ts, 0, 0)) ->P : Symbol(P, Decl(mappedTypes3.ts, 1, 10)) +>P : Symbol(P, Decl(mappedTypes3.ts, 0, 10)) value: P; ->value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) ->P : Symbol(P, Decl(mappedTypes3.ts, 1, 10)) +>value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) +>P : Symbol(P, Decl(mappedTypes3.ts, 0, 10)) } type Boxified = { ->Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 3, 1)) ->T : Symbol(T, Decl(mappedTypes3.ts, 5, 14)) +>Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 2, 1)) +>T : Symbol(T, Decl(mappedTypes3.ts, 4, 14)) [K in keyof T]: Box; ->K : Symbol(K, Decl(mappedTypes3.ts, 6, 5)) ->T : Symbol(T, Decl(mappedTypes3.ts, 5, 14)) +>K : Symbol(K, Decl(mappedTypes3.ts, 5, 5)) +>T : Symbol(T, Decl(mappedTypes3.ts, 4, 14)) >Box : Symbol(Box, Decl(mappedTypes3.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes3.ts, 5, 14)) ->K : Symbol(K, Decl(mappedTypes3.ts, 6, 5)) +>T : Symbol(T, Decl(mappedTypes3.ts, 4, 14)) +>K : Symbol(K, Decl(mappedTypes3.ts, 5, 5)) } declare function boxify(obj: T): Boxified; ->boxify : Symbol(boxify, Decl(mappedTypes3.ts, 7, 1)) ->T : Symbol(T, Decl(mappedTypes3.ts, 9, 24)) ->obj : Symbol(obj, Decl(mappedTypes3.ts, 9, 27)) ->T : Symbol(T, Decl(mappedTypes3.ts, 9, 24)) ->Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 3, 1)) ->T : Symbol(T, Decl(mappedTypes3.ts, 9, 24)) +>boxify : Symbol(boxify, Decl(mappedTypes3.ts, 6, 1)) +>T : Symbol(T, Decl(mappedTypes3.ts, 8, 24)) +>obj : Symbol(obj, Decl(mappedTypes3.ts, 8, 27)) +>T : Symbol(T, Decl(mappedTypes3.ts, 8, 24)) +>Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 2, 1)) +>T : Symbol(T, Decl(mappedTypes3.ts, 8, 24)) declare function unboxify(obj: Boxified): T; ->unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 9, 48)) ->T : Symbol(T, Decl(mappedTypes3.ts, 10, 26)) ->obj : Symbol(obj, Decl(mappedTypes3.ts, 10, 29)) ->Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 3, 1)) ->T : Symbol(T, Decl(mappedTypes3.ts, 10, 26)) ->T : Symbol(T, Decl(mappedTypes3.ts, 10, 26)) +>unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 8, 48)) +>T : Symbol(T, Decl(mappedTypes3.ts, 9, 26)) +>obj : Symbol(obj, Decl(mappedTypes3.ts, 9, 29)) +>Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 2, 1)) +>T : Symbol(T, Decl(mappedTypes3.ts, 9, 26)) +>T : Symbol(T, Decl(mappedTypes3.ts, 9, 26)) interface Bacon { ->Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 10, 50)) +>Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 9, 50)) isPerfect: boolean; ->isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) +>isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) weight: number; ->weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 13, 23)) +>weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 12, 23)) } interface BoxifiedBacon { ->BoxifiedBacon : Symbol(BoxifiedBacon, Decl(mappedTypes3.ts, 15, 1)) +>BoxifiedBacon : Symbol(BoxifiedBacon, Decl(mappedTypes3.ts, 14, 1)) isPerfect: Box; ->isPerfect : Symbol(BoxifiedBacon.isPerfect, Decl(mappedTypes3.ts, 17, 25)) +>isPerfect : Symbol(BoxifiedBacon.isPerfect, Decl(mappedTypes3.ts, 16, 25)) >Box : Symbol(Box, Decl(mappedTypes3.ts, 0, 0)) weight: Box; ->weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 18, 28)) +>weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 17, 28)) >Box : Symbol(Box, Decl(mappedTypes3.ts, 0, 0)) } function f1(b: Bacon) { ->f1 : Symbol(f1, Decl(mappedTypes3.ts, 20, 1)) ->b : Symbol(b, Decl(mappedTypes3.ts, 22, 12)) ->Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 10, 50)) +>f1 : Symbol(f1, Decl(mappedTypes3.ts, 19, 1)) +>b : Symbol(b, Decl(mappedTypes3.ts, 21, 12)) +>Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 9, 50)) let bb = boxify(b); ->bb : Symbol(bb, Decl(mappedTypes3.ts, 23, 7)) ->boxify : Symbol(boxify, Decl(mappedTypes3.ts, 7, 1)) ->b : Symbol(b, Decl(mappedTypes3.ts, 22, 12)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 22, 7)) +>boxify : Symbol(boxify, Decl(mappedTypes3.ts, 6, 1)) +>b : Symbol(b, Decl(mappedTypes3.ts, 21, 12)) let isPerfect = bb.isPerfect.value; ->isPerfect : Symbol(isPerfect, Decl(mappedTypes3.ts, 24, 7)) ->bb.isPerfect.value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) +>isPerfect : Symbol(isPerfect, Decl(mappedTypes3.ts, 23, 7)) +>bb.isPerfect.value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) >bb.isPerfect : Symbol(isPerfect) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 23, 7)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 22, 7)) >isPerfect : Symbol(isPerfect) ->value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) +>value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) let weight = bb.weight.value; ->weight : Symbol(weight, Decl(mappedTypes3.ts, 25, 7)) ->bb.weight.value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) +>weight : Symbol(weight, Decl(mappedTypes3.ts, 24, 7)) +>bb.weight.value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) >bb.weight : Symbol(weight) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 23, 7)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 22, 7)) >weight : Symbol(weight) ->value : Symbol(Box.value, Decl(mappedTypes3.ts, 1, 14)) +>value : Symbol(Box.value, Decl(mappedTypes3.ts, 0, 14)) } function f2(bb: Boxified) { ->f2 : Symbol(f2, Decl(mappedTypes3.ts, 26, 1)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 28, 12)) ->Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 3, 1)) ->Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 10, 50)) +>f2 : Symbol(f2, Decl(mappedTypes3.ts, 25, 1)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 27, 12)) +>Boxified : Symbol(Boxified, Decl(mappedTypes3.ts, 2, 1)) +>Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 9, 50)) let b = unboxify(bb); // Infer Bacon for T ->b : Symbol(b, Decl(mappedTypes3.ts, 29, 7)) ->unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 9, 48)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 28, 12)) +>b : Symbol(b, Decl(mappedTypes3.ts, 28, 7)) +>unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 8, 48)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 27, 12)) let bool = b.isPerfect; ->bool : Symbol(bool, Decl(mappedTypes3.ts, 30, 7)) ->b.isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) ->b : Symbol(b, Decl(mappedTypes3.ts, 29, 7)) ->isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) +>bool : Symbol(bool, Decl(mappedTypes3.ts, 29, 7)) +>b.isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) +>b : Symbol(b, Decl(mappedTypes3.ts, 28, 7)) +>isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) let weight = b.weight; ->weight : Symbol(weight, Decl(mappedTypes3.ts, 31, 7)) ->b.weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 13, 23)) ->b : Symbol(b, Decl(mappedTypes3.ts, 29, 7)) ->weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 13, 23)) +>weight : Symbol(weight, Decl(mappedTypes3.ts, 30, 7)) +>b.weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 12, 23)) +>b : Symbol(b, Decl(mappedTypes3.ts, 28, 7)) +>weight : Symbol(Bacon.weight, Decl(mappedTypes3.ts, 12, 23)) } function f3(bb: BoxifiedBacon) { ->f3 : Symbol(f3, Decl(mappedTypes3.ts, 32, 1)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 34, 12)) ->BoxifiedBacon : Symbol(BoxifiedBacon, Decl(mappedTypes3.ts, 15, 1)) +>f3 : Symbol(f3, Decl(mappedTypes3.ts, 31, 1)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 33, 12)) +>BoxifiedBacon : Symbol(BoxifiedBacon, Decl(mappedTypes3.ts, 14, 1)) let b = unboxify(bb); // Explicit type parameter required ->b : Symbol(b, Decl(mappedTypes3.ts, 35, 7)) ->unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 9, 48)) ->Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 10, 50)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 34, 12)) +>b : Symbol(b, Decl(mappedTypes3.ts, 34, 7)) +>unboxify : Symbol(unboxify, Decl(mappedTypes3.ts, 8, 48)) +>Bacon : Symbol(Bacon, Decl(mappedTypes3.ts, 9, 50)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 33, 12)) let bool = b.isPerfect; ->bool : Symbol(bool, Decl(mappedTypes3.ts, 36, 7)) ->b.isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) ->b : Symbol(b, Decl(mappedTypes3.ts, 35, 7)) ->isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 12, 17)) +>bool : Symbol(bool, Decl(mappedTypes3.ts, 35, 7)) +>b.isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) +>b : Symbol(b, Decl(mappedTypes3.ts, 34, 7)) +>isPerfect : Symbol(Bacon.isPerfect, Decl(mappedTypes3.ts, 11, 17)) let weight = bb.weight; ->weight : Symbol(weight, Decl(mappedTypes3.ts, 37, 7)) ->bb.weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 18, 28)) ->bb : Symbol(bb, Decl(mappedTypes3.ts, 34, 12)) ->weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 18, 28)) +>weight : Symbol(weight, Decl(mappedTypes3.ts, 36, 7)) +>bb.weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 17, 28)) +>bb : Symbol(bb, Decl(mappedTypes3.ts, 33, 12)) +>weight : Symbol(BoxifiedBacon.weight, Decl(mappedTypes3.ts, 17, 28)) } diff --git a/tests/baselines/reference/mappedTypes3.types b/tests/baselines/reference/mappedTypes3.types index 36471938d751c..3428e8b98bdc5 100644 --- a/tests/baselines/reference/mappedTypes3.types +++ b/tests/baselines/reference/mappedTypes3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypes3.ts === - class Box

{ >Box : Box

>P : P diff --git a/tests/baselines/reference/mappedTypes4.js b/tests/baselines/reference/mappedTypes4.js index 963538d2269df..395d6490b4e60 100644 --- a/tests/baselines/reference/mappedTypes4.js +++ b/tests/baselines/reference/mappedTypes4.js @@ -1,5 +1,4 @@ //// [mappedTypes4.ts] - type Box = { }; diff --git a/tests/baselines/reference/mappedTypes4.symbols b/tests/baselines/reference/mappedTypes4.symbols index ed108b47d7879..6c42cb5dea071 100644 --- a/tests/baselines/reference/mappedTypes4.symbols +++ b/tests/baselines/reference/mappedTypes4.symbols @@ -1,229 +1,228 @@ === tests/cases/conformance/types/mapped/mappedTypes4.ts === - type Box = { >Box : Symbol(Box, Decl(mappedTypes4.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes4.ts, 1, 9)) +>T : Symbol(T, Decl(mappedTypes4.ts, 0, 9)) }; type Boxified = { ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) ->T : Symbol(T, Decl(mappedTypes4.ts, 4, 14)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) +>T : Symbol(T, Decl(mappedTypes4.ts, 3, 14)) [P in keyof T]: Box; ->P : Symbol(P, Decl(mappedTypes4.ts, 5, 5)) ->T : Symbol(T, Decl(mappedTypes4.ts, 4, 14)) +>P : Symbol(P, Decl(mappedTypes4.ts, 4, 5)) +>T : Symbol(T, Decl(mappedTypes4.ts, 3, 14)) >Box : Symbol(Box, Decl(mappedTypes4.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes4.ts, 4, 14)) ->P : Symbol(P, Decl(mappedTypes4.ts, 5, 5)) +>T : Symbol(T, Decl(mappedTypes4.ts, 3, 14)) +>P : Symbol(P, Decl(mappedTypes4.ts, 4, 5)) }; function boxify(obj: T): Boxified { ->boxify : Symbol(boxify, Decl(mappedTypes4.ts, 6, 2)) ->T : Symbol(T, Decl(mappedTypes4.ts, 8, 16)) ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) ->T : Symbol(T, Decl(mappedTypes4.ts, 8, 16)) ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) ->T : Symbol(T, Decl(mappedTypes4.ts, 8, 16)) +>boxify : Symbol(boxify, Decl(mappedTypes4.ts, 5, 2)) +>T : Symbol(T, Decl(mappedTypes4.ts, 7, 16)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) +>T : Symbol(T, Decl(mappedTypes4.ts, 7, 16)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) +>T : Symbol(T, Decl(mappedTypes4.ts, 7, 16)) if (typeof obj === "object") { ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) let result = {} as Boxified; ->result : Symbol(result, Decl(mappedTypes4.ts, 10, 11)) ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) ->T : Symbol(T, Decl(mappedTypes4.ts, 8, 16)) +>result : Symbol(result, Decl(mappedTypes4.ts, 9, 11)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) +>T : Symbol(T, Decl(mappedTypes4.ts, 7, 16)) for (let k in obj) { ->k : Symbol(k, Decl(mappedTypes4.ts, 11, 16)) ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) +>k : Symbol(k, Decl(mappedTypes4.ts, 10, 16)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) result[k] = { value: obj[k] }; ->result : Symbol(result, Decl(mappedTypes4.ts, 10, 11)) ->k : Symbol(k, Decl(mappedTypes4.ts, 11, 16)) ->value : Symbol(value, Decl(mappedTypes4.ts, 12, 25)) ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) ->k : Symbol(k, Decl(mappedTypes4.ts, 11, 16)) +>result : Symbol(result, Decl(mappedTypes4.ts, 9, 11)) +>k : Symbol(k, Decl(mappedTypes4.ts, 10, 16)) +>value : Symbol(value, Decl(mappedTypes4.ts, 11, 25)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) +>k : Symbol(k, Decl(mappedTypes4.ts, 10, 16)) } return result; ->result : Symbol(result, Decl(mappedTypes4.ts, 10, 11)) +>result : Symbol(result, Decl(mappedTypes4.ts, 9, 11)) } return obj; ->obj : Symbol(obj, Decl(mappedTypes4.ts, 8, 19)) +>obj : Symbol(obj, Decl(mappedTypes4.ts, 7, 19)) } type A = { a: string }; ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->a : Symbol(a, Decl(mappedTypes4.ts, 19, 10)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>a : Symbol(a, Decl(mappedTypes4.ts, 18, 10)) type B = { b: string }; ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->b : Symbol(b, Decl(mappedTypes4.ts, 20, 10)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>b : Symbol(b, Decl(mappedTypes4.ts, 19, 10)) type C = { c: string }; ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) ->c : Symbol(c, Decl(mappedTypes4.ts, 21, 10)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) +>c : Symbol(c, Decl(mappedTypes4.ts, 20, 10)) function f1(x: A | B | C | undefined) { ->f1 : Symbol(f1, Decl(mappedTypes4.ts, 21, 23)) ->x : Symbol(x, Decl(mappedTypes4.ts, 23, 12)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>f1 : Symbol(f1, Decl(mappedTypes4.ts, 20, 23)) +>x : Symbol(x, Decl(mappedTypes4.ts, 22, 12)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) return boxify(x); ->boxify : Symbol(boxify, Decl(mappedTypes4.ts, 6, 2)) ->x : Symbol(x, Decl(mappedTypes4.ts, 23, 12)) +>boxify : Symbol(boxify, Decl(mappedTypes4.ts, 5, 2)) +>x : Symbol(x, Decl(mappedTypes4.ts, 22, 12)) } type T00 = Partial; ->T00 : Symbol(T00, Decl(mappedTypes4.ts, 25, 1)) +>T00 : Symbol(T00, Decl(mappedTypes4.ts, 24, 1)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T01 = Readonly; ->T01 : Symbol(T01, Decl(mappedTypes4.ts, 27, 30)) +>T01 : Symbol(T01, Decl(mappedTypes4.ts, 26, 30)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T02 = Boxified ->T02 : Symbol(T02, Decl(mappedTypes4.ts, 28, 50)) ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>T02 : Symbol(T02, Decl(mappedTypes4.ts, 27, 50)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T03 = Readonly; ->T03 : Symbol(T03, Decl(mappedTypes4.ts, 29, 41)) +>T03 : Symbol(T03, Decl(mappedTypes4.ts, 28, 41)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) type T04 = Boxified; ->T04 : Symbol(T04, Decl(mappedTypes4.ts, 30, 73)) ->Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 2, 2)) +>T04 : Symbol(T04, Decl(mappedTypes4.ts, 29, 73)) +>Boxified : Symbol(Boxified, Decl(mappedTypes4.ts, 1, 2)) type T05 = Partial<"hello" | "world" | 42>; ->T05 : Symbol(T05, Decl(mappedTypes4.ts, 31, 73)) +>T05 : Symbol(T05, Decl(mappedTypes4.ts, 30, 73)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) type BoxifiedWithSentinel = { ->BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 32, 43)) ->T : Symbol(T, Decl(mappedTypes4.ts, 34, 26)) ->U : Symbol(U, Decl(mappedTypes4.ts, 34, 28)) +>BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 31, 43)) +>T : Symbol(T, Decl(mappedTypes4.ts, 33, 26)) +>U : Symbol(U, Decl(mappedTypes4.ts, 33, 28)) [P in keyof T]: Box | U; ->P : Symbol(P, Decl(mappedTypes4.ts, 35, 5)) ->T : Symbol(T, Decl(mappedTypes4.ts, 34, 26)) +>P : Symbol(P, Decl(mappedTypes4.ts, 34, 5)) +>T : Symbol(T, Decl(mappedTypes4.ts, 33, 26)) >Box : Symbol(Box, Decl(mappedTypes4.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypes4.ts, 34, 26)) ->P : Symbol(P, Decl(mappedTypes4.ts, 35, 5)) ->U : Symbol(U, Decl(mappedTypes4.ts, 34, 28)) +>T : Symbol(T, Decl(mappedTypes4.ts, 33, 26)) +>P : Symbol(P, Decl(mappedTypes4.ts, 34, 5)) +>U : Symbol(U, Decl(mappedTypes4.ts, 33, 28)) } type T10 = BoxifiedWithSentinel; ->T10 : Symbol(T10, Decl(mappedTypes4.ts, 36, 1)) ->BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 32, 43)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>T10 : Symbol(T10, Decl(mappedTypes4.ts, 35, 1)) +>BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 31, 43)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T11 = BoxifiedWithSentinel; ->T11 : Symbol(T11, Decl(mappedTypes4.ts, 38, 49)) ->BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 32, 43)) ->A : Symbol(A, Decl(mappedTypes4.ts, 17, 1)) ->B : Symbol(B, Decl(mappedTypes4.ts, 19, 23)) ->C : Symbol(C, Decl(mappedTypes4.ts, 20, 23)) +>T11 : Symbol(T11, Decl(mappedTypes4.ts, 37, 49)) +>BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 31, 43)) +>A : Symbol(A, Decl(mappedTypes4.ts, 16, 1)) +>B : Symbol(B, Decl(mappedTypes4.ts, 18, 23)) +>C : Symbol(C, Decl(mappedTypes4.ts, 19, 23)) type T12 = BoxifiedWithSentinel; ->T12 : Symbol(T12, Decl(mappedTypes4.ts, 39, 54)) ->BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 32, 43)) +>T12 : Symbol(T12, Decl(mappedTypes4.ts, 38, 54)) +>BoxifiedWithSentinel : Symbol(BoxifiedWithSentinel, Decl(mappedTypes4.ts, 31, 43)) type DeepReadonly = { ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 40, 51)) ->T : Symbol(T, Decl(mappedTypes4.ts, 42, 18)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 39, 51)) +>T : Symbol(T, Decl(mappedTypes4.ts, 41, 18)) readonly [P in keyof T]: DeepReadonly; ->P : Symbol(P, Decl(mappedTypes4.ts, 43, 14)) ->T : Symbol(T, Decl(mappedTypes4.ts, 42, 18)) ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 40, 51)) ->T : Symbol(T, Decl(mappedTypes4.ts, 42, 18)) ->P : Symbol(P, Decl(mappedTypes4.ts, 43, 14)) +>P : Symbol(P, Decl(mappedTypes4.ts, 42, 14)) +>T : Symbol(T, Decl(mappedTypes4.ts, 41, 18)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 39, 51)) +>T : Symbol(T, Decl(mappedTypes4.ts, 41, 18)) +>P : Symbol(P, Decl(mappedTypes4.ts, 42, 14)) }; type Foo = { ->Foo : Symbol(Foo, Decl(mappedTypes4.ts, 44, 2)) +>Foo : Symbol(Foo, Decl(mappedTypes4.ts, 43, 2)) x: number; ->x : Symbol(x, Decl(mappedTypes4.ts, 46, 12)) +>x : Symbol(x, Decl(mappedTypes4.ts, 45, 12)) y: { a: string, b: number }; ->y : Symbol(y, Decl(mappedTypes4.ts, 47, 14)) ->a : Symbol(a, Decl(mappedTypes4.ts, 48, 8)) ->b : Symbol(b, Decl(mappedTypes4.ts, 48, 19)) +>y : Symbol(y, Decl(mappedTypes4.ts, 46, 14)) +>a : Symbol(a, Decl(mappedTypes4.ts, 47, 8)) +>b : Symbol(b, Decl(mappedTypes4.ts, 47, 19)) z: boolean; ->z : Symbol(z, Decl(mappedTypes4.ts, 48, 32)) +>z : Symbol(z, Decl(mappedTypes4.ts, 47, 32)) }; type DeepReadonlyFoo = { ->DeepReadonlyFoo : Symbol(DeepReadonlyFoo, Decl(mappedTypes4.ts, 50, 2)) +>DeepReadonlyFoo : Symbol(DeepReadonlyFoo, Decl(mappedTypes4.ts, 49, 2)) readonly x: number; ->x : Symbol(x, Decl(mappedTypes4.ts, 52, 24)) +>x : Symbol(x, Decl(mappedTypes4.ts, 51, 24)) readonly y: { readonly a: string, readonly b: number }; ->y : Symbol(y, Decl(mappedTypes4.ts, 53, 23)) ->a : Symbol(a, Decl(mappedTypes4.ts, 54, 17)) ->b : Symbol(b, Decl(mappedTypes4.ts, 54, 37)) +>y : Symbol(y, Decl(mappedTypes4.ts, 52, 23)) +>a : Symbol(a, Decl(mappedTypes4.ts, 53, 17)) +>b : Symbol(b, Decl(mappedTypes4.ts, 53, 37)) readonly z: boolean; ->z : Symbol(z, Decl(mappedTypes4.ts, 54, 59)) +>z : Symbol(z, Decl(mappedTypes4.ts, 53, 59)) }; var x1: DeepReadonly; ->x1 : Symbol(x1, Decl(mappedTypes4.ts, 58, 3), Decl(mappedTypes4.ts, 59, 3)) ->DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 40, 51)) ->Foo : Symbol(Foo, Decl(mappedTypes4.ts, 44, 2)) +>x1 : Symbol(x1, Decl(mappedTypes4.ts, 57, 3), Decl(mappedTypes4.ts, 58, 3)) +>DeepReadonly : Symbol(DeepReadonly, Decl(mappedTypes4.ts, 39, 51)) +>Foo : Symbol(Foo, Decl(mappedTypes4.ts, 43, 2)) var x1: DeepReadonlyFoo; ->x1 : Symbol(x1, Decl(mappedTypes4.ts, 58, 3), Decl(mappedTypes4.ts, 59, 3)) ->DeepReadonlyFoo : Symbol(DeepReadonlyFoo, Decl(mappedTypes4.ts, 50, 2)) +>x1 : Symbol(x1, Decl(mappedTypes4.ts, 57, 3), Decl(mappedTypes4.ts, 58, 3)) +>DeepReadonlyFoo : Symbol(DeepReadonlyFoo, Decl(mappedTypes4.ts, 49, 2)) // Repro from #13232 type Z = { a: number }; ->Z : Symbol(Z, Decl(mappedTypes4.ts, 59, 24)) ->a : Symbol(a, Decl(mappedTypes4.ts, 63, 10)) +>Z : Symbol(Z, Decl(mappedTypes4.ts, 58, 24)) +>a : Symbol(a, Decl(mappedTypes4.ts, 62, 10)) type Clone = { ->Clone : Symbol(Clone, Decl(mappedTypes4.ts, 63, 23)) ->T : Symbol(T, Decl(mappedTypes4.ts, 64, 11)) +>Clone : Symbol(Clone, Decl(mappedTypes4.ts, 62, 23)) +>T : Symbol(T, Decl(mappedTypes4.ts, 63, 11)) [P in keyof (T & {})]: T[P]; ->P : Symbol(P, Decl(mappedTypes4.ts, 65, 3)) ->T : Symbol(T, Decl(mappedTypes4.ts, 64, 11)) ->T : Symbol(T, Decl(mappedTypes4.ts, 64, 11)) ->P : Symbol(P, Decl(mappedTypes4.ts, 65, 3)) +>P : Symbol(P, Decl(mappedTypes4.ts, 64, 3)) +>T : Symbol(T, Decl(mappedTypes4.ts, 63, 11)) +>T : Symbol(T, Decl(mappedTypes4.ts, 63, 11)) +>P : Symbol(P, Decl(mappedTypes4.ts, 64, 3)) }; type M = Clone; // M should be { a: number } ->M : Symbol(M, Decl(mappedTypes4.ts, 66, 2)) ->Clone : Symbol(Clone, Decl(mappedTypes4.ts, 63, 23)) ->Z : Symbol(Z, Decl(mappedTypes4.ts, 59, 24)) +>M : Symbol(M, Decl(mappedTypes4.ts, 65, 2)) +>Clone : Symbol(Clone, Decl(mappedTypes4.ts, 62, 23)) +>Z : Symbol(Z, Decl(mappedTypes4.ts, 58, 24)) var z1: Z; ->z1 : Symbol(z1, Decl(mappedTypes4.ts, 69, 3), Decl(mappedTypes4.ts, 70, 3)) ->Z : Symbol(Z, Decl(mappedTypes4.ts, 59, 24)) +>z1 : Symbol(z1, Decl(mappedTypes4.ts, 68, 3), Decl(mappedTypes4.ts, 69, 3)) +>Z : Symbol(Z, Decl(mappedTypes4.ts, 58, 24)) var z1: Clone; ->z1 : Symbol(z1, Decl(mappedTypes4.ts, 69, 3), Decl(mappedTypes4.ts, 70, 3)) ->Clone : Symbol(Clone, Decl(mappedTypes4.ts, 63, 23)) ->Z : Symbol(Z, Decl(mappedTypes4.ts, 59, 24)) +>z1 : Symbol(z1, Decl(mappedTypes4.ts, 68, 3), Decl(mappedTypes4.ts, 69, 3)) +>Clone : Symbol(Clone, Decl(mappedTypes4.ts, 62, 23)) +>Z : Symbol(Z, Decl(mappedTypes4.ts, 58, 24)) diff --git a/tests/baselines/reference/mappedTypes4.types b/tests/baselines/reference/mappedTypes4.types index 1d0c4c16b8955..30e7eb2431bf3 100644 --- a/tests/baselines/reference/mappedTypes4.types +++ b/tests/baselines/reference/mappedTypes4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypes4.ts === - type Box = { >Box : Box >T : T diff --git a/tests/baselines/reference/mappedTypesAndObjects.js b/tests/baselines/reference/mappedTypesAndObjects.js index f320cc9624e89..664f3b9572dc7 100644 --- a/tests/baselines/reference/mappedTypesAndObjects.js +++ b/tests/baselines/reference/mappedTypesAndObjects.js @@ -1,5 +1,4 @@ //// [mappedTypesAndObjects.ts] - function f1(x: Partial, y: Readonly) { let obj: {}; obj = x; diff --git a/tests/baselines/reference/mappedTypesAndObjects.symbols b/tests/baselines/reference/mappedTypesAndObjects.symbols index 6fb5d720fb34f..2bbab833343d4 100644 --- a/tests/baselines/reference/mappedTypesAndObjects.symbols +++ b/tests/baselines/reference/mappedTypesAndObjects.symbols @@ -1,124 +1,123 @@ === tests/cases/conformance/types/mapped/mappedTypesAndObjects.ts === - function f1(x: Partial, y: Readonly) { >f1 : Symbol(f1, Decl(mappedTypesAndObjects.ts, 0, 0)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 1, 12)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 1, 15)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 0, 12)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 0, 15)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 1, 12)) ->y : Symbol(y, Decl(mappedTypesAndObjects.ts, 1, 29)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 0, 12)) +>y : Symbol(y, Decl(mappedTypesAndObjects.ts, 0, 29)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 1, 12)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 0, 12)) let obj: {}; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 2, 7)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 1, 7)) obj = x; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 2, 7)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 1, 15)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 1, 7)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 0, 15)) obj = y; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 2, 7)) ->y : Symbol(y, Decl(mappedTypesAndObjects.ts, 1, 29)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 1, 7)) +>y : Symbol(y, Decl(mappedTypesAndObjects.ts, 0, 29)) } function f2(x: Partial, y: Readonly) { ->f2 : Symbol(f2, Decl(mappedTypesAndObjects.ts, 5, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 7, 12)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 7, 15)) +>f2 : Symbol(f2, Decl(mappedTypesAndObjects.ts, 4, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 6, 12)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 6, 15)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 7, 12)) ->y : Symbol(y, Decl(mappedTypesAndObjects.ts, 7, 29)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 6, 12)) +>y : Symbol(y, Decl(mappedTypesAndObjects.ts, 6, 29)) >Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 7, 12)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 6, 12)) let obj: { [x: string]: any }; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 8, 7)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 8, 16)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 7, 7)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 7, 16)) obj = x; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 8, 7)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 7, 15)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 7, 7)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 6, 15)) obj = y; ->obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 8, 7)) ->y : Symbol(y, Decl(mappedTypesAndObjects.ts, 7, 29)) +>obj : Symbol(obj, Decl(mappedTypesAndObjects.ts, 7, 7)) +>y : Symbol(y, Decl(mappedTypesAndObjects.ts, 6, 29)) } function f3(x: Partial) { ->f3 : Symbol(f3, Decl(mappedTypesAndObjects.ts, 11, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 13, 12)) ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 13, 15)) +>f3 : Symbol(f3, Decl(mappedTypesAndObjects.ts, 10, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 12, 12)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 12, 15)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 13, 12)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 12, 12)) x = {}; ->x : Symbol(x, Decl(mappedTypesAndObjects.ts, 13, 15)) +>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 12, 15)) } // Repro from #12900 interface Base { ->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1)) +>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 14, 1)) foo: { [key: string]: any }; ->foo : Symbol(Base.foo, Decl(mappedTypesAndObjects.ts, 19, 16)) ->key : Symbol(key, Decl(mappedTypesAndObjects.ts, 20, 12)) +>foo : Symbol(Base.foo, Decl(mappedTypesAndObjects.ts, 18, 16)) +>key : Symbol(key, Decl(mappedTypesAndObjects.ts, 19, 12)) bar: any; ->bar : Symbol(Base.bar, Decl(mappedTypesAndObjects.ts, 20, 32)) +>bar : Symbol(Base.bar, Decl(mappedTypesAndObjects.ts, 19, 32)) baz: any; ->baz : Symbol(Base.baz, Decl(mappedTypesAndObjects.ts, 21, 13)) +>baz : Symbol(Base.baz, Decl(mappedTypesAndObjects.ts, 20, 13)) } interface E1 extends Base { ->E1 : Symbol(E1, Decl(mappedTypesAndObjects.ts, 23, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 25, 13)) ->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1)) +>E1 : Symbol(E1, Decl(mappedTypesAndObjects.ts, 22, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 24, 13)) +>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 14, 1)) foo: T; ->foo : Symbol(E1.foo, Decl(mappedTypesAndObjects.ts, 25, 30)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 25, 13)) +>foo : Symbol(E1.foo, Decl(mappedTypesAndObjects.ts, 24, 30)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 24, 13)) } interface Something { name: string, value: string }; ->Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 27, 1)) ->name : Symbol(Something.name, Decl(mappedTypesAndObjects.ts, 29, 21)) ->value : Symbol(Something.value, Decl(mappedTypesAndObjects.ts, 29, 35)) +>Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 26, 1)) +>name : Symbol(Something.name, Decl(mappedTypesAndObjects.ts, 28, 21)) +>value : Symbol(Something.value, Decl(mappedTypesAndObjects.ts, 28, 35)) interface E2 extends Base { ->E2 : Symbol(E2, Decl(mappedTypesAndObjects.ts, 29, 52)) ->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1)) +>E2 : Symbol(E2, Decl(mappedTypesAndObjects.ts, 28, 52)) +>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 14, 1)) foo: Partial; // or other mapped type ->foo : Symbol(E2.foo, Decl(mappedTypesAndObjects.ts, 30, 27)) +>foo : Symbol(E2.foo, Decl(mappedTypesAndObjects.ts, 29, 27)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 27, 1)) +>Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 26, 1)) } interface E3 extends Base { ->E3 : Symbol(E3, Decl(mappedTypesAndObjects.ts, 32, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 34, 13)) ->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1)) +>E3 : Symbol(E3, Decl(mappedTypesAndObjects.ts, 31, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 33, 13)) +>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 14, 1)) foo: Partial; // or other mapped type ->foo : Symbol(E3.foo, Decl(mappedTypesAndObjects.ts, 34, 30)) +>foo : Symbol(E3.foo, Decl(mappedTypesAndObjects.ts, 33, 30)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 34, 13)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 33, 13)) } // Repro from #13747 class Form { ->Form : Symbol(Form, Decl(mappedTypesAndObjects.ts, 36, 1)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 40, 11)) +>Form : Symbol(Form, Decl(mappedTypesAndObjects.ts, 35, 1)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 39, 11)) private values: {[P in keyof T]?: T[P]} = {} ->values : Symbol(Form.values, Decl(mappedTypesAndObjects.ts, 40, 15)) ->P : Symbol(P, Decl(mappedTypesAndObjects.ts, 41, 22)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 40, 11)) ->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 40, 11)) ->P : Symbol(P, Decl(mappedTypesAndObjects.ts, 41, 22)) +>values : Symbol(Form.values, Decl(mappedTypesAndObjects.ts, 39, 15)) +>P : Symbol(P, Decl(mappedTypesAndObjects.ts, 40, 22)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 39, 11)) +>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 39, 11)) +>P : Symbol(P, Decl(mappedTypesAndObjects.ts, 40, 22)) } diff --git a/tests/baselines/reference/mappedTypesAndObjects.types b/tests/baselines/reference/mappedTypesAndObjects.types index 75f71082f310d..78acf606396ca 100644 --- a/tests/baselines/reference/mappedTypesAndObjects.types +++ b/tests/baselines/reference/mappedTypesAndObjects.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/mapped/mappedTypesAndObjects.ts === - function f1(x: Partial, y: Readonly) { >f1 : (x: Partial, y: Readonly) => void >T : T diff --git a/tests/baselines/reference/mergeClassInterfaceAndModule.js b/tests/baselines/reference/mergeClassInterfaceAndModule.js index 5b7315031cd21..132a19478084f 100644 --- a/tests/baselines/reference/mergeClassInterfaceAndModule.js +++ b/tests/baselines/reference/mergeClassInterfaceAndModule.js @@ -1,5 +1,4 @@ //// [mergeClassInterfaceAndModule.ts] - interface C1 {} declare class C1 {} module C1 {} diff --git a/tests/baselines/reference/mergeClassInterfaceAndModule.symbols b/tests/baselines/reference/mergeClassInterfaceAndModule.symbols index a10227ed4618b..eae65b622f768 100644 --- a/tests/baselines/reference/mergeClassInterfaceAndModule.symbols +++ b/tests/baselines/reference/mergeClassInterfaceAndModule.symbols @@ -1,38 +1,37 @@ === tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts === - interface C1 {} ->C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 1, 15), Decl(mergeClassInterfaceAndModule.ts, 2, 19)) +>C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 0, 15), Decl(mergeClassInterfaceAndModule.ts, 1, 19)) declare class C1 {} ->C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 1, 15), Decl(mergeClassInterfaceAndModule.ts, 2, 19)) +>C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 0, 15), Decl(mergeClassInterfaceAndModule.ts, 1, 19)) module C1 {} ->C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 1, 15), Decl(mergeClassInterfaceAndModule.ts, 2, 19)) +>C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 0, 15), Decl(mergeClassInterfaceAndModule.ts, 1, 19)) declare class C2 {} ->C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 3, 12), Decl(mergeClassInterfaceAndModule.ts, 5, 19), Decl(mergeClassInterfaceAndModule.ts, 6, 15)) +>C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 2, 12), Decl(mergeClassInterfaceAndModule.ts, 4, 19), Decl(mergeClassInterfaceAndModule.ts, 5, 15)) interface C2 {} ->C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 3, 12), Decl(mergeClassInterfaceAndModule.ts, 5, 19), Decl(mergeClassInterfaceAndModule.ts, 6, 15)) +>C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 2, 12), Decl(mergeClassInterfaceAndModule.ts, 4, 19), Decl(mergeClassInterfaceAndModule.ts, 5, 15)) module C2 {} ->C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 3, 12), Decl(mergeClassInterfaceAndModule.ts, 5, 19), Decl(mergeClassInterfaceAndModule.ts, 6, 15)) +>C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 2, 12), Decl(mergeClassInterfaceAndModule.ts, 4, 19), Decl(mergeClassInterfaceAndModule.ts, 5, 15)) declare class C3 {} ->C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 7, 12), Decl(mergeClassInterfaceAndModule.ts, 9, 19), Decl(mergeClassInterfaceAndModule.ts, 10, 12)) +>C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 6, 12), Decl(mergeClassInterfaceAndModule.ts, 8, 19), Decl(mergeClassInterfaceAndModule.ts, 9, 12)) module C3 {} ->C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 7, 12), Decl(mergeClassInterfaceAndModule.ts, 9, 19), Decl(mergeClassInterfaceAndModule.ts, 10, 12)) +>C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 6, 12), Decl(mergeClassInterfaceAndModule.ts, 8, 19), Decl(mergeClassInterfaceAndModule.ts, 9, 12)) interface C3 {} ->C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 7, 12), Decl(mergeClassInterfaceAndModule.ts, 9, 19), Decl(mergeClassInterfaceAndModule.ts, 10, 12)) +>C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 6, 12), Decl(mergeClassInterfaceAndModule.ts, 8, 19), Decl(mergeClassInterfaceAndModule.ts, 9, 12)) module C4 {} ->C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 11, 15), Decl(mergeClassInterfaceAndModule.ts, 13, 12), Decl(mergeClassInterfaceAndModule.ts, 14, 19)) +>C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 10, 15), Decl(mergeClassInterfaceAndModule.ts, 12, 12), Decl(mergeClassInterfaceAndModule.ts, 13, 19)) declare class C4 {} // error -- class declaration must preceed module declaration ->C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 11, 15), Decl(mergeClassInterfaceAndModule.ts, 13, 12), Decl(mergeClassInterfaceAndModule.ts, 14, 19)) +>C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 10, 15), Decl(mergeClassInterfaceAndModule.ts, 12, 12), Decl(mergeClassInterfaceAndModule.ts, 13, 19)) interface C4 {} ->C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 11, 15), Decl(mergeClassInterfaceAndModule.ts, 13, 12), Decl(mergeClassInterfaceAndModule.ts, 14, 19)) +>C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 10, 15), Decl(mergeClassInterfaceAndModule.ts, 12, 12), Decl(mergeClassInterfaceAndModule.ts, 13, 19)) diff --git a/tests/baselines/reference/mergeClassInterfaceAndModule.types b/tests/baselines/reference/mergeClassInterfaceAndModule.types index a91691e5bacda..9bb1ebeba7003 100644 --- a/tests/baselines/reference/mergeClassInterfaceAndModule.types +++ b/tests/baselines/reference/mergeClassInterfaceAndModule.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts === - interface C1 {} >C1 : C1 diff --git a/tests/baselines/reference/mergedClassInterface.js b/tests/baselines/reference/mergedClassInterface.js index 913c0472cbd51..54f806f20177e 100644 --- a/tests/baselines/reference/mergedClassInterface.js +++ b/tests/baselines/reference/mergedClassInterface.js @@ -1,8 +1,6 @@ //// [tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts] //// //// [file1.ts] - - declare class C1 { } interface C1 { } @@ -43,13 +41,11 @@ c5.x3; c5.x4; //// [file2.ts] - declare class C6 { } interface C7 { } //// [file3.ts] - interface C6 { } declare class C7 { } diff --git a/tests/baselines/reference/mergedClassInterface.symbols b/tests/baselines/reference/mergedClassInterface.symbols index 8de9a9557c1cc..d37dc46cb523c 100644 --- a/tests/baselines/reference/mergedClassInterface.symbols +++ b/tests/baselines/reference/mergedClassInterface.symbols @@ -1,96 +1,92 @@ === tests/cases/conformance/classes/classDeclarations/file1.ts === - - declare class C1 { } ->C1 : Symbol(C1, Decl(file1.ts, 0, 0), Decl(file1.ts, 2, 20)) +>C1 : Symbol(C1, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 20)) interface C1 { } ->C1 : Symbol(C1, Decl(file1.ts, 0, 0), Decl(file1.ts, 2, 20)) +>C1 : Symbol(C1, Decl(file1.ts, 0, 0), Decl(file1.ts, 0, 20)) interface C2 { } ->C2 : Symbol(C2, Decl(file1.ts, 4, 16), Decl(file1.ts, 6, 16)) +>C2 : Symbol(C2, Decl(file1.ts, 2, 16), Decl(file1.ts, 4, 16)) declare class C2 { } ->C2 : Symbol(C2, Decl(file1.ts, 4, 16), Decl(file1.ts, 6, 16)) +>C2 : Symbol(C2, Decl(file1.ts, 2, 16), Decl(file1.ts, 4, 16)) class C3 { } ->C3 : Symbol(C3, Decl(file1.ts, 8, 20), Decl(file1.ts, 10, 12)) +>C3 : Symbol(C3, Decl(file1.ts, 6, 20), Decl(file1.ts, 8, 12)) interface C3 { } ->C3 : Symbol(C3, Decl(file1.ts, 8, 20), Decl(file1.ts, 10, 12)) +>C3 : Symbol(C3, Decl(file1.ts, 6, 20), Decl(file1.ts, 8, 12)) interface C4 { } ->C4 : Symbol(C4, Decl(file1.ts, 12, 16), Decl(file1.ts, 14, 16)) +>C4 : Symbol(C4, Decl(file1.ts, 10, 16), Decl(file1.ts, 12, 16)) class C4 { } ->C4 : Symbol(C4, Decl(file1.ts, 12, 16), Decl(file1.ts, 14, 16)) +>C4 : Symbol(C4, Decl(file1.ts, 10, 16), Decl(file1.ts, 12, 16)) interface C5 { ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) x1: number; ->x1 : Symbol(C5.x1, Decl(file1.ts, 18, 14)) +>x1 : Symbol(C5.x1, Decl(file1.ts, 16, 14)) } declare class C5 { ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) x2: number; ->x2 : Symbol(C5.x2, Decl(file1.ts, 22, 18)) +>x2 : Symbol(C5.x2, Decl(file1.ts, 20, 18)) } interface C5 { ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) x3: number; ->x3 : Symbol(C5.x3, Decl(file1.ts, 26, 14)) +>x3 : Symbol(C5.x3, Decl(file1.ts, 24, 14)) } interface C5 { ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) x4: number; ->x4 : Symbol(C5.x4, Decl(file1.ts, 30, 14)) +>x4 : Symbol(C5.x4, Decl(file1.ts, 28, 14)) } // checks if properties actually were merged var c5 : C5; ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->C5 : Symbol(C5, Decl(file1.ts, 16, 12), Decl(file1.ts, 20, 1), Decl(file1.ts, 24, 1), Decl(file1.ts, 28, 1)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>C5 : Symbol(C5, Decl(file1.ts, 14, 12), Decl(file1.ts, 18, 1), Decl(file1.ts, 22, 1), Decl(file1.ts, 26, 1)) c5.x1; ->c5.x1 : Symbol(C5.x1, Decl(file1.ts, 18, 14)) ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->x1 : Symbol(C5.x1, Decl(file1.ts, 18, 14)) +>c5.x1 : Symbol(C5.x1, Decl(file1.ts, 16, 14)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>x1 : Symbol(C5.x1, Decl(file1.ts, 16, 14)) c5.x2; ->c5.x2 : Symbol(C5.x2, Decl(file1.ts, 22, 18)) ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->x2 : Symbol(C5.x2, Decl(file1.ts, 22, 18)) +>c5.x2 : Symbol(C5.x2, Decl(file1.ts, 20, 18)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>x2 : Symbol(C5.x2, Decl(file1.ts, 20, 18)) c5.x3; ->c5.x3 : Symbol(C5.x3, Decl(file1.ts, 26, 14)) ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->x3 : Symbol(C5.x3, Decl(file1.ts, 26, 14)) +>c5.x3 : Symbol(C5.x3, Decl(file1.ts, 24, 14)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>x3 : Symbol(C5.x3, Decl(file1.ts, 24, 14)) c5.x4; ->c5.x4 : Symbol(C5.x4, Decl(file1.ts, 30, 14)) ->c5 : Symbol(c5, Decl(file1.ts, 35, 3)) ->x4 : Symbol(C5.x4, Decl(file1.ts, 30, 14)) +>c5.x4 : Symbol(C5.x4, Decl(file1.ts, 28, 14)) +>c5 : Symbol(c5, Decl(file1.ts, 33, 3)) +>x4 : Symbol(C5.x4, Decl(file1.ts, 28, 14)) === tests/cases/conformance/classes/classDeclarations/file2.ts === - declare class C6 { } >C6 : Symbol(C6, Decl(file2.ts, 0, 0), Decl(file3.ts, 0, 0)) interface C7 { } ->C7 : Symbol(C7, Decl(file2.ts, 1, 20), Decl(file3.ts, 1, 16)) +>C7 : Symbol(C7, Decl(file2.ts, 0, 20), Decl(file3.ts, 0, 16)) === tests/cases/conformance/classes/classDeclarations/file3.ts === - interface C6 { } >C6 : Symbol(C6, Decl(file2.ts, 0, 0), Decl(file3.ts, 0, 0)) declare class C7 { } ->C7 : Symbol(C7, Decl(file2.ts, 1, 20), Decl(file3.ts, 1, 16)) +>C7 : Symbol(C7, Decl(file2.ts, 0, 20), Decl(file3.ts, 0, 16)) diff --git a/tests/baselines/reference/mergedClassInterface.types b/tests/baselines/reference/mergedClassInterface.types index 4c3a6cca6a97f..b58f26d0112fb 100644 --- a/tests/baselines/reference/mergedClassInterface.types +++ b/tests/baselines/reference/mergedClassInterface.types @@ -1,6 +1,4 @@ === tests/cases/conformance/classes/classDeclarations/file1.ts === - - declare class C1 { } >C1 : C1 @@ -79,7 +77,6 @@ c5.x4; >x4 : number === tests/cases/conformance/classes/classDeclarations/file2.ts === - declare class C6 { } >C6 : C6 @@ -87,7 +84,6 @@ interface C7 { } >C7 : C7 === tests/cases/conformance/classes/classDeclarations/file3.ts === - interface C6 { } >C6 : C6 diff --git a/tests/baselines/reference/mergedDeclarations6.js b/tests/baselines/reference/mergedDeclarations6.js index 83173f35752d2..2b492b569c250 100644 --- a/tests/baselines/reference/mergedDeclarations6.js +++ b/tests/baselines/reference/mergedDeclarations6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/mergedDeclarations6.ts] //// //// [a.ts] - export class A { protected protected: any; diff --git a/tests/baselines/reference/mergedDeclarations6.symbols b/tests/baselines/reference/mergedDeclarations6.symbols index a51dcf75e9c42..7a10ff260a2ed 100644 --- a/tests/baselines/reference/mergedDeclarations6.symbols +++ b/tests/baselines/reference/mergedDeclarations6.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/a.ts === - export class A { >A : Symbol(A, Decl(a.ts, 0, 0), Decl(b.ts, 2, 22)) protected protected: any; ->protected : Symbol(A.protected, Decl(a.ts, 1, 16)) +>protected : Symbol(A.protected, Decl(a.ts, 0, 16)) protected setProtected(val: any) { ->setProtected : Symbol(A.setProtected, Decl(a.ts, 2, 29)) ->val : Symbol(val, Decl(a.ts, 4, 27)) +>setProtected : Symbol(A.setProtected, Decl(a.ts, 1, 29)) +>val : Symbol(val, Decl(a.ts, 3, 27)) this.protected = val; ->this.protected : Symbol(A.protected, Decl(a.ts, 1, 16)) +>this.protected : Symbol(A.protected, Decl(a.ts, 0, 16)) >this : Symbol(A, Decl(a.ts, 0, 0), Decl(b.ts, 2, 22)) ->protected : Symbol(A.protected, Decl(a.ts, 1, 16)) ->val : Symbol(val, Decl(a.ts, 4, 27)) +>protected : Symbol(A.protected, Decl(a.ts, 0, 16)) +>val : Symbol(val, Decl(a.ts, 3, 27)) } } diff --git a/tests/baselines/reference/mergedDeclarations6.types b/tests/baselines/reference/mergedDeclarations6.types index 6198c08f6b5d2..d6c109f65976c 100644 --- a/tests/baselines/reference/mergedDeclarations6.types +++ b/tests/baselines/reference/mergedDeclarations6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A { >A : A diff --git a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.js b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.js index ab1eafa1c9cd0..31f25d22b791c 100644 --- a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.js +++ b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/mergedInterfaceFromMultipleFiles1.ts] //// //// [mergedInterfaceFromMultipleFiles1_0.ts] - interface I { foo(): string; } interface C extends I { diff --git a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols index 4dffd06bcde6c..bb197a97aeb35 100644 --- a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols +++ b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols @@ -6,7 +6,7 @@ interface D { bar(): number; } >bar : Symbol(D.bar, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 13)) interface C extends D { ->C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) +>C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) >D : Symbol(D, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 0, 0)) b(): Date; @@ -16,13 +16,13 @@ interface C extends D { var c:C; >c : Symbol(c, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 8, 3)) ->C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) +>C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) var a: string = c.foo(); >a : Symbol(a, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 9, 3)) ->c.foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 13)) +>c.foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 13)) >c : Symbol(c, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 8, 3)) ->foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 13)) +>foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 13)) var b: number = c.bar(); >b : Symbol(b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 10, 3)) @@ -32,9 +32,9 @@ var b: number = c.bar(); var d: number = c.a(); >d : Symbol(d, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 11, 3)) ->c.a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 3, 23)) +>c.a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 2, 23)) >c : Symbol(c, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 8, 3)) ->a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 3, 23)) +>a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 2, 23)) var e: Date = c.b(); >e : Symbol(e, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 12, 3)) @@ -44,16 +44,15 @@ var e: Date = c.b(); >b : Symbol(C.b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23)) === tests/cases/compiler/mergedInterfaceFromMultipleFiles1_0.ts === - interface I { foo(): string; } >I : Symbol(I, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 0)) ->foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 13)) +>foo : Symbol(I.foo, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 13)) interface C extends I { ->C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 1, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) +>C : Symbol(C, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 30), Decl(mergedInterfaceFromMultipleFiles1_1.ts, 2, 30)) >I : Symbol(I, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 0, 0)) a(): number; ->a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 3, 23)) +>a : Symbol(C.a, Decl(mergedInterfaceFromMultipleFiles1_0.ts, 2, 23)) } diff --git a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.types b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.types index ad6b07f0312e6..374017d45dfd7 100644 --- a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.types +++ b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.types @@ -48,7 +48,6 @@ var e: Date = c.b(); >b : () => Date === tests/cases/compiler/mergedInterfaceFromMultipleFiles1_0.ts === - interface I { foo(): string; } >I : I >foo : () => string diff --git a/tests/baselines/reference/metadataOfEventAlias.js b/tests/baselines/reference/metadataOfEventAlias.js index 40cbc87cdcb67..b46d5cade630a 100644 --- a/tests/baselines/reference/metadataOfEventAlias.js +++ b/tests/baselines/reference/metadataOfEventAlias.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/metadataOfEventAlias.ts] //// //// [event.ts] - export interface Event { title: string }; //// [test.ts] diff --git a/tests/baselines/reference/metadataOfEventAlias.symbols b/tests/baselines/reference/metadataOfEventAlias.symbols index 441714e63e6d4..15f27cbca23af 100644 --- a/tests/baselines/reference/metadataOfEventAlias.symbols +++ b/tests/baselines/reference/metadataOfEventAlias.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/event.ts === - export interface Event { title: string }; >Event : Symbol(Event, Decl(event.ts, 0, 0)) ->title : Symbol(Event.title, Decl(event.ts, 1, 24)) +>title : Symbol(Event.title, Decl(event.ts, 0, 24)) === tests/cases/compiler/test.ts === import { Event } from './event'; diff --git a/tests/baselines/reference/metadataOfEventAlias.types b/tests/baselines/reference/metadataOfEventAlias.types index b644552f9c2c9..01b97bfbac1a2 100644 --- a/tests/baselines/reference/metadataOfEventAlias.types +++ b/tests/baselines/reference/metadataOfEventAlias.types @@ -1,5 +1,4 @@ === tests/cases/compiler/event.ts === - export interface Event { title: string }; >Event : Event >title : string diff --git a/tests/baselines/reference/missingDecoratorType.errors.txt b/tests/baselines/reference/missingDecoratorType.errors.txt index f2af7d49b5754..b944335630654 100644 --- a/tests/baselines/reference/missingDecoratorType.errors.txt +++ b/tests/baselines/reference/missingDecoratorType.errors.txt @@ -3,7 +3,6 @@ error TS2318: Cannot find global type 'TypedPropertyDescriptor'. !!! error TS2318: Cannot find global type 'TypedPropertyDescriptor'. ==== tests/cases/conformance/decorators/a.ts (0 errors) ==== - interface Object { } interface Array { } interface String { } diff --git a/tests/baselines/reference/missingDecoratorType.js b/tests/baselines/reference/missingDecoratorType.js index 1dcbb3febc5e9..ee9fbf7ce440a 100644 --- a/tests/baselines/reference/missingDecoratorType.js +++ b/tests/baselines/reference/missingDecoratorType.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/decorators/missingDecoratorType.ts] //// //// [a.ts] - interface Object { } interface Array { } interface String { } diff --git a/tests/baselines/reference/missingFunctionImplementation.errors.txt b/tests/baselines/reference/missingFunctionImplementation.errors.txt index 4cf58d97d4909..1bb938fca0759 100644 --- a/tests/baselines/reference/missingFunctionImplementation.errors.txt +++ b/tests/baselines/reference/missingFunctionImplementation.errors.txt @@ -1,26 +1,25 @@ -tests/cases/compiler/missingFunctionImplementation.ts(3,3): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(8,3): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(16,3): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(22,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(28,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(33,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(41,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(2,3): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(7,3): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(15,3): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(21,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(27,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(32,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(40,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(47,10): error TS2300: Duplicate identifier 'm'. tests/cases/compiler/missingFunctionImplementation.ts(48,10): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(49,10): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(49,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(52,19): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(57,10): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(60,19): error TS2300: Duplicate identifier 'm'. -tests/cases/compiler/missingFunctionImplementation.ts(60,19): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/compiler/missingFunctionImplementation.ts(65,19): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(48,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(51,19): error TS2300: Duplicate identifier 'm'. +tests/cases/compiler/missingFunctionImplementation.ts(56,10): error TS2300: Duplicate identifier 'm'. +tests/cases/compiler/missingFunctionImplementation.ts(59,19): error TS2300: Duplicate identifier 'm'. +tests/cases/compiler/missingFunctionImplementation.ts(59,19): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(64,19): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/missingFunctionImplementation.ts(72,19): error TS2393: Duplicate function implementation. tests/cases/compiler/missingFunctionImplementation.ts(73,19): error TS2393: Duplicate function implementation. tests/cases/compiler/missingFunctionImplementation.ts(74,19): error TS2393: Duplicate function implementation. -tests/cases/compiler/missingFunctionImplementation.ts(75,19): error TS2393: Duplicate function implementation. -tests/cases/compiler/missingFunctionImplementation.ts(78,19): error TS2393: Duplicate function implementation. +tests/cases/compiler/missingFunctionImplementation.ts(77,19): error TS2393: Duplicate function implementation. ==== tests/cases/compiler/missingFunctionImplementation.ts (19 errors) ==== - export class C1 { m(): void; ~ diff --git a/tests/baselines/reference/missingFunctionImplementation.js b/tests/baselines/reference/missingFunctionImplementation.js index 23bb2356640ed..5ca505dff85ba 100644 --- a/tests/baselines/reference/missingFunctionImplementation.js +++ b/tests/baselines/reference/missingFunctionImplementation.js @@ -1,5 +1,4 @@ //// [missingFunctionImplementation.ts] - export class C1 { m(): void; } diff --git a/tests/baselines/reference/missingImportAfterModuleImport.js b/tests/baselines/reference/missingImportAfterModuleImport.js index 2739ced1cdd94..7d63c07b8223f 100644 --- a/tests/baselines/reference/missingImportAfterModuleImport.js +++ b/tests/baselines/reference/missingImportAfterModuleImport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/missingImportAfterModuleImport.ts] //// //// [missingImportAfterModuleImport_0.ts] - declare module "SubModule" { class SubModule { public static StaticVar: number; diff --git a/tests/baselines/reference/missingImportAfterModuleImport.symbols b/tests/baselines/reference/missingImportAfterModuleImport.symbols index 5493d58c528c1..1b8de78e41b33 100644 --- a/tests/baselines/reference/missingImportAfterModuleImport.symbols +++ b/tests/baselines/reference/missingImportAfterModuleImport.symbols @@ -18,20 +18,19 @@ export = MainModule; === tests/cases/compiler/missingImportAfterModuleImport_0.ts === - declare module "SubModule" { class SubModule { ->SubModule : Symbol(SubModule, Decl(missingImportAfterModuleImport_0.ts, 1, 28)) +>SubModule : Symbol(SubModule, Decl(missingImportAfterModuleImport_0.ts, 0, 28)) public static StaticVar: number; ->StaticVar : Symbol(SubModule.StaticVar, Decl(missingImportAfterModuleImport_0.ts, 2, 21)) +>StaticVar : Symbol(SubModule.StaticVar, Decl(missingImportAfterModuleImport_0.ts, 1, 21)) public InstanceVar: number; ->InstanceVar : Symbol(SubModule.InstanceVar, Decl(missingImportAfterModuleImport_0.ts, 3, 40)) +>InstanceVar : Symbol(SubModule.InstanceVar, Decl(missingImportAfterModuleImport_0.ts, 2, 40)) constructor(); } export = SubModule; ->SubModule : Symbol(SubModule, Decl(missingImportAfterModuleImport_0.ts, 1, 28)) +>SubModule : Symbol(SubModule, Decl(missingImportAfterModuleImport_0.ts, 0, 28)) } diff --git a/tests/baselines/reference/missingImportAfterModuleImport.types b/tests/baselines/reference/missingImportAfterModuleImport.types index b8602ca06d019..41cdc9195d445 100644 --- a/tests/baselines/reference/missingImportAfterModuleImport.types +++ b/tests/baselines/reference/missingImportAfterModuleImport.types @@ -18,7 +18,6 @@ export = MainModule; === tests/cases/compiler/missingImportAfterModuleImport_0.ts === - declare module "SubModule" { class SubModule { >SubModule : SubModule diff --git a/tests/baselines/reference/missingSemicolonInModuleSpecifier.js b/tests/baselines/reference/missingSemicolonInModuleSpecifier.js index d4a8b12d2a669..889f2b800be14 100644 --- a/tests/baselines/reference/missingSemicolonInModuleSpecifier.js +++ b/tests/baselines/reference/missingSemicolonInModuleSpecifier.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/missingSemicolonInModuleSpecifier.ts] //// //// [a.ts] - export const x = 1; //// [b.ts] diff --git a/tests/baselines/reference/missingSemicolonInModuleSpecifier.symbols b/tests/baselines/reference/missingSemicolonInModuleSpecifier.symbols index 695779002acd3..bd0d6c4c9aa83 100644 --- a/tests/baselines/reference/missingSemicolonInModuleSpecifier.symbols +++ b/tests/baselines/reference/missingSemicolonInModuleSpecifier.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/a.ts === - export const x = 1; ->x : Symbol(x, Decl(a.ts, 1, 12)) +>x : Symbol(x, Decl(a.ts, 0, 12)) === tests/cases/compiler/b.ts === import {x} from "./a" diff --git a/tests/baselines/reference/missingSemicolonInModuleSpecifier.types b/tests/baselines/reference/missingSemicolonInModuleSpecifier.types index f7730558b68a8..96e043e047fd4 100644 --- a/tests/baselines/reference/missingSemicolonInModuleSpecifier.types +++ b/tests/baselines/reference/missingSemicolonInModuleSpecifier.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export const x = 1; >x : 1 >1 : 1 diff --git a/tests/baselines/reference/misspelledJsDocTypedefTags.symbols b/tests/baselines/reference/misspelledJsDocTypedefTags.symbols index bf3f6e7fab085..a073734946649 100644 --- a/tests/baselines/reference/misspelledJsDocTypedefTags.symbols +++ b/tests/baselines/reference/misspelledJsDocTypedefTags.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/a.js === - -No type information for this code./** @typedef {{ endTime: number, screenshots: number}} A.*/ +/** @typedef {{ endTime: number, screenshots: number}} A.*/ No type information for this code.Animation.AnimationModel.ScreenshotCapture.Request; No type information for this code. No type information for this code./** @typedef {{ endTime: number, screenshots: !B.}} */ diff --git a/tests/baselines/reference/misspelledJsDocTypedefTags.types b/tests/baselines/reference/misspelledJsDocTypedefTags.types index 70cc011ea69e1..4c483029e6c4c 100644 --- a/tests/baselines/reference/misspelledJsDocTypedefTags.types +++ b/tests/baselines/reference/misspelledJsDocTypedefTags.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.js === - /** @typedef {{ endTime: number, screenshots: number}} A.*/ Animation.AnimationModel.ScreenshotCapture.Request; >Animation.AnimationModel.ScreenshotCapture.Request : any diff --git a/tests/baselines/reference/mixinAccessModifiers.errors.txt b/tests/baselines/reference/mixinAccessModifiers.errors.txt index be82571e02bf9..a93725e01d236 100644 --- a/tests/baselines/reference/mixinAccessModifiers.errors.txt +++ b/tests/baselines/reference/mixinAccessModifiers.errors.txt @@ -1,30 +1,29 @@ -tests/cases/conformance/classes/mixinAccessModifiers.ts(39,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Private2'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(43,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Protected'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(47,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Public'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(51,4): error TS2445: Property 'p' is protected and only accessible within class 'Protected & Protected2' and its subclasses. -tests/cases/conformance/classes/mixinAccessModifiers.ts(66,7): error TS2415: Class 'C1' incorrectly extends base class 'Private & Private2'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(38,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Private2'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(42,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Protected'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(46,4): error TS2546: Property 'p' has conflicting declarations and is inaccessible in type 'Private & Public'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(50,4): error TS2445: Property 'p' is protected and only accessible within class 'Protected & Protected2' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(65,7): error TS2415: Class 'C1' incorrectly extends base class 'Private & Private2'. Type 'C1' is not assignable to type 'Private'. Property 'p' has conflicting declarations and is inaccessible in type 'C1'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(66,7): error TS4093: 'extends' clause of exported class 'C1' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(67,7): error TS2415: Class 'C2' incorrectly extends base class 'Private & Protected'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(65,7): error TS4093: 'extends' clause of exported class 'C1' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(66,7): error TS2415: Class 'C2' incorrectly extends base class 'Private & Protected'. Type 'C2' is not assignable to type 'Private'. Property 'p' has conflicting declarations and is inaccessible in type 'C2'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(67,7): error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(68,7): error TS2415: Class 'C3' incorrectly extends base class 'Private & Public'. +tests/cases/conformance/classes/mixinAccessModifiers.ts(66,7): error TS4093: 'extends' clause of exported class 'C2' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(67,7): error TS2415: Class 'C3' incorrectly extends base class 'Private & Public'. Type 'C3' is not assignable to type 'Private'. Property 'p' has conflicting declarations and is inaccessible in type 'C3'. -tests/cases/conformance/classes/mixinAccessModifiers.ts(68,7): error TS4093: 'extends' clause of exported class 'C3' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(70,7): error TS4093: 'extends' clause of exported class 'C4' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(83,7): error TS4093: 'extends' clause of exported class 'C5' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(85,6): error TS2445: Property 'p' is protected and only accessible within class 'C4' and its subclasses. -tests/cases/conformance/classes/mixinAccessModifiers.ts(90,6): error TS2445: Property 's' is protected and only accessible within class 'typeof C4' and its subclasses. -tests/cases/conformance/classes/mixinAccessModifiers.ts(96,7): error TS4093: 'extends' clause of exported class 'C6' refers to a type whose name cannot be referenced. -tests/cases/conformance/classes/mixinAccessModifiers.ts(98,6): error TS2445: Property 'p' is protected and only accessible within class 'C4' and its subclasses. -tests/cases/conformance/classes/mixinAccessModifiers.ts(103,6): error TS2445: Property 's' is protected and only accessible within class 'typeof C4' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(67,7): error TS4093: 'extends' clause of exported class 'C3' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(69,7): error TS4093: 'extends' clause of exported class 'C4' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(82,7): error TS4093: 'extends' clause of exported class 'C5' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(84,6): error TS2445: Property 'p' is protected and only accessible within class 'C4' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(89,6): error TS2445: Property 's' is protected and only accessible within class 'typeof C4' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(95,7): error TS4093: 'extends' clause of exported class 'C6' refers to a type whose name cannot be referenced. +tests/cases/conformance/classes/mixinAccessModifiers.ts(97,6): error TS2445: Property 'p' is protected and only accessible within class 'C4' and its subclasses. +tests/cases/conformance/classes/mixinAccessModifiers.ts(102,6): error TS2445: Property 's' is protected and only accessible within class 'typeof C4' and its subclasses. ==== tests/cases/conformance/classes/mixinAccessModifiers.ts (17 errors) ==== - type Constructable = new (...args: any[]) => object; class Private { diff --git a/tests/baselines/reference/mixinAccessModifiers.js b/tests/baselines/reference/mixinAccessModifiers.js index 1db30e37a6e19..8100c9db9e955 100644 --- a/tests/baselines/reference/mixinAccessModifiers.js +++ b/tests/baselines/reference/mixinAccessModifiers.js @@ -1,5 +1,4 @@ //// [mixinAccessModifiers.ts] - type Constructable = new (...args: any[]) => object; class Private { diff --git a/tests/baselines/reference/mixinClassesAnnotated.js b/tests/baselines/reference/mixinClassesAnnotated.js index e3a781033ff47..15282a11dd8fc 100644 --- a/tests/baselines/reference/mixinClassesAnnotated.js +++ b/tests/baselines/reference/mixinClassesAnnotated.js @@ -1,5 +1,4 @@ //// [mixinClassesAnnotated.ts] - type Constructor = new(...args: any[]) => T; class Base { diff --git a/tests/baselines/reference/mixinClassesAnnotated.symbols b/tests/baselines/reference/mixinClassesAnnotated.symbols index 5a03789e2e672..419428e6c5310 100644 --- a/tests/baselines/reference/mixinClassesAnnotated.symbols +++ b/tests/baselines/reference/mixinClassesAnnotated.symbols @@ -1,193 +1,192 @@ === tests/cases/conformance/classes/mixinClassesAnnotated.ts === - type Constructor = new(...args: any[]) => T; >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 1, 17)) ->args : Symbol(args, Decl(mixinClassesAnnotated.ts, 1, 26)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 1, 17)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 0, 17)) +>args : Symbol(args, Decl(mixinClassesAnnotated.ts, 0, 26)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 0, 17)) class Base { ->Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47)) +>Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 0, 47)) constructor(public x: number, public y: number) {} ->x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 4, 33)) +>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 3, 33)) } class Derived extends Base { ->Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 5, 1)) ->Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47)) +>Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 4, 1)) +>Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 0, 47)) constructor(x: number, y: number, public z: number) { ->x : Symbol(x, Decl(mixinClassesAnnotated.ts, 8, 16)) ->y : Symbol(y, Decl(mixinClassesAnnotated.ts, 8, 26)) ->z : Symbol(Derived.z, Decl(mixinClassesAnnotated.ts, 8, 37)) +>x : Symbol(x, Decl(mixinClassesAnnotated.ts, 7, 16)) +>y : Symbol(y, Decl(mixinClassesAnnotated.ts, 7, 26)) +>z : Symbol(Derived.z, Decl(mixinClassesAnnotated.ts, 7, 37)) super(x, y); ->super : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47)) ->x : Symbol(x, Decl(mixinClassesAnnotated.ts, 8, 16)) ->y : Symbol(y, Decl(mixinClassesAnnotated.ts, 8, 26)) +>super : Symbol(Base, Decl(mixinClassesAnnotated.ts, 0, 47)) +>x : Symbol(x, Decl(mixinClassesAnnotated.ts, 7, 16)) +>y : Symbol(y, Decl(mixinClassesAnnotated.ts, 7, 26)) } } interface Printable { ->Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5)) +>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 10, 1), Decl(mixinClassesAnnotated.ts, 16, 5)) print(): void; ->print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) +>print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) } const Printable = >(superClass: T): Constructor & { message: string } & T => ->Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 17, 19)) +>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 10, 1), Decl(mixinClassesAnnotated.ts, 16, 5)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 16, 19)) >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47)) ->superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 17, 48)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 17, 19)) +>Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 0, 47)) +>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 16, 48)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 16, 19)) >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5)) ->message : Symbol(message, Decl(mixinClassesAnnotated.ts, 17, 90)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 17, 19)) +>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 10, 1), Decl(mixinClassesAnnotated.ts, 16, 5)) +>message : Symbol(message, Decl(mixinClassesAnnotated.ts, 16, 90)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 16, 19)) class extends superClass { ->superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 17, 48)) +>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 16, 48)) static message = "hello"; ->message : Symbol((Anonymous class).message, Decl(mixinClassesAnnotated.ts, 18, 30)) +>message : Symbol((Anonymous class).message, Decl(mixinClassesAnnotated.ts, 17, 30)) print() { ->print : Symbol((Anonymous class).print, Decl(mixinClassesAnnotated.ts, 19, 33)) +>print : Symbol((Anonymous class).print, Decl(mixinClassesAnnotated.ts, 18, 33)) const output = this.x + "," + this.y; ->output : Symbol(output, Decl(mixinClassesAnnotated.ts, 21, 17)) ->this.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 17, 115)) ->x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->this.y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 4, 33)) ->this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 17, 115)) ->y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 4, 33)) +>output : Symbol(output, Decl(mixinClassesAnnotated.ts, 20, 17)) +>this.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 16, 115)) +>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>this.y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 3, 33)) +>this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 16, 115)) +>y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 3, 33)) } } interface Tagged { ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) _tag: string; ->_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) +>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) } function Tagged>(superClass: T): Constructor & T { ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 28, 16)) >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 29, 43)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16)) +>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 28, 43)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 28, 16)) >Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0)) ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) ->T : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) +>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 28, 16)) class C extends superClass { ->C : Symbol(C, Decl(mixinClassesAnnotated.ts, 29, 84)) ->superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 29, 43)) +>C : Symbol(C, Decl(mixinClassesAnnotated.ts, 28, 84)) +>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 28, 43)) _tag: string; ->_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 30, 32)) +>_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 29, 32)) constructor(...args: any[]) { ->args : Symbol(args, Decl(mixinClassesAnnotated.ts, 32, 20)) +>args : Symbol(args, Decl(mixinClassesAnnotated.ts, 31, 20)) super(...args); ->super : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16)) ->args : Symbol(args, Decl(mixinClassesAnnotated.ts, 32, 20)) +>super : Symbol(T, Decl(mixinClassesAnnotated.ts, 28, 16)) +>args : Symbol(args, Decl(mixinClassesAnnotated.ts, 31, 20)) this._tag = "hello"; ->this._tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 30, 32)) ->this : Symbol(C, Decl(mixinClassesAnnotated.ts, 29, 84)) ->_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 30, 32)) +>this._tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 29, 32)) +>this : Symbol(C, Decl(mixinClassesAnnotated.ts, 28, 84)) +>_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 29, 32)) } } return C; ->C : Symbol(C, Decl(mixinClassesAnnotated.ts, 29, 84)) +>C : Symbol(C, Decl(mixinClassesAnnotated.ts, 28, 84)) } const Thing1 = Tagged(Derived); ->Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 40, 5)) ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) ->Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 5, 1)) +>Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 39, 5)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) +>Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 4, 1)) const Thing2 = Tagged(Printable(Derived)); ->Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5)) ->Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1)) ->Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5)) ->Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 5, 1)) +>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 40, 5)) +>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 22, 5), Decl(mixinClassesAnnotated.ts, 26, 1)) +>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 10, 1), Decl(mixinClassesAnnotated.ts, 16, 5)) +>Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 4, 1)) Thing2.message; ->Thing2.message : Symbol(message, Decl(mixinClassesAnnotated.ts, 17, 90)) ->Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5)) ->message : Symbol(message, Decl(mixinClassesAnnotated.ts, 17, 90)) +>Thing2.message : Symbol(message, Decl(mixinClassesAnnotated.ts, 16, 90)) +>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 40, 5)) +>message : Symbol(message, Decl(mixinClassesAnnotated.ts, 16, 90)) function f1() { ->f1 : Symbol(f1, Decl(mixinClassesAnnotated.ts, 42, 15)) +>f1 : Symbol(f1, Decl(mixinClassesAnnotated.ts, 41, 15)) const thing = new Thing1(1, 2, 3); ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 45, 9)) ->Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 40, 5)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 44, 9)) +>Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 39, 5)) thing.x; ->thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 45, 9)) ->x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) +>thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 44, 9)) +>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) thing._tag; ->thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 45, 9)) ->_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) +>thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 44, 9)) +>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) } function f2() { ->f2 : Symbol(f2, Decl(mixinClassesAnnotated.ts, 48, 1)) +>f2 : Symbol(f2, Decl(mixinClassesAnnotated.ts, 47, 1)) const thing = new Thing2(1, 2, 3); ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9)) ->Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 50, 9)) +>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 40, 5)) thing.x; ->thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9)) ->x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16)) +>thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 50, 9)) +>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 3, 16)) thing._tag; ->thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9)) ->_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) +>thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 50, 9)) +>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) thing.print(); ->thing.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) ->thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9)) ->print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) +>thing.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) +>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 50, 9)) +>print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) } class Thing3 extends Thing2 { ->Thing3 : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 55, 1)) ->Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5)) +>Thing3 : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 54, 1)) +>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 40, 5)) constructor(tag: string) { ->tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 58, 16)) +>tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 57, 16)) super(10, 20, 30); this._tag = tag; ->this._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) ->this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 55, 1)) ->_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18)) ->tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 58, 16)) +>this._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) +>this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 54, 1)) +>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 24, 18)) +>tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 57, 16)) } test() { ->test : Symbol(Thing3.test, Decl(mixinClassesAnnotated.ts, 61, 5)) +>test : Symbol(Thing3.test, Decl(mixinClassesAnnotated.ts, 60, 5)) this.print(); ->this.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) ->this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 55, 1)) ->print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21)) +>this.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) +>this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 54, 1)) +>print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 12, 21)) } } diff --git a/tests/baselines/reference/mixinClassesAnnotated.types b/tests/baselines/reference/mixinClassesAnnotated.types index afaf4c4d25ec1..9d30171e3d891 100644 --- a/tests/baselines/reference/mixinClassesAnnotated.types +++ b/tests/baselines/reference/mixinClassesAnnotated.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/mixinClassesAnnotated.ts === - type Constructor = new(...args: any[]) => T; >Constructor : Constructor >T : T diff --git a/tests/baselines/reference/mixinClassesMembers.js b/tests/baselines/reference/mixinClassesMembers.js index 01fc1bb003295..4771cec384d61 100644 --- a/tests/baselines/reference/mixinClassesMembers.js +++ b/tests/baselines/reference/mixinClassesMembers.js @@ -1,5 +1,4 @@ //// [mixinClassesMembers.ts] - declare class C1 { public a: number; protected b: number; diff --git a/tests/baselines/reference/mixinClassesMembers.symbols b/tests/baselines/reference/mixinClassesMembers.symbols index fabfe7e6d8630..35c8bb9f17f1e 100644 --- a/tests/baselines/reference/mixinClassesMembers.symbols +++ b/tests/baselines/reference/mixinClassesMembers.symbols @@ -1,309 +1,308 @@ === tests/cases/conformance/classes/mixinClassesMembers.ts === - declare class C1 { >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) public a: number; ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) protected b: number; ->b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) +>b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) private c: number; ->c : Symbol(C1.c, Decl(mixinClassesMembers.ts, 3, 24)) +>c : Symbol(C1.c, Decl(mixinClassesMembers.ts, 2, 24)) constructor(s: string); ->s : Symbol(s, Decl(mixinClassesMembers.ts, 5, 16)) +>s : Symbol(s, Decl(mixinClassesMembers.ts, 4, 16)) constructor(n: number); ->n : Symbol(n, Decl(mixinClassesMembers.ts, 6, 16)) +>n : Symbol(n, Decl(mixinClassesMembers.ts, 5, 16)) } declare class M1 { ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) constructor(...args: any[]); ->args : Symbol(args, Decl(mixinClassesMembers.ts, 10, 16)) +>args : Symbol(args, Decl(mixinClassesMembers.ts, 9, 16)) p: number; ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) static p: number; ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) } declare class M2 { ->M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1)) +>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 12, 1)) constructor(...args: any[]); ->args : Symbol(args, Decl(mixinClassesMembers.ts, 16, 16)) +>args : Symbol(args, Decl(mixinClassesMembers.ts, 15, 16)) f(): number; ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) static f(): number; ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) } declare const Mixed1: typeof M1 & typeof C1; ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) declare const Mixed2: typeof C1 & typeof M1; ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) declare const Mixed3: typeof M2 & typeof M1 & typeof C1; ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) ->M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) +>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 12, 1)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) declare const Mixed4: typeof C1 & typeof M1 & typeof M2; ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) >C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) ->M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) +>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 12, 1)) declare const Mixed5: typeof M1 & typeof M2; ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) ->M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1)) ->M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) +>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 6, 1)) +>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 12, 1)) function f1() { ->f1 : Symbol(f1, Decl(mixinClassesMembers.ts, 25, 44)) +>f1 : Symbol(f1, Decl(mixinClassesMembers.ts, 24, 44)) let x1 = new Mixed1("hello"); ->x1 : Symbol(x1, Decl(mixinClassesMembers.ts, 28, 7)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) +>x1 : Symbol(x1, Decl(mixinClassesMembers.ts, 27, 7)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) let x2 = new Mixed1(42); ->x2 : Symbol(x2, Decl(mixinClassesMembers.ts, 29, 7)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) +>x2 : Symbol(x2, Decl(mixinClassesMembers.ts, 28, 7)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) let x3 = new Mixed2("hello"); ->x3 : Symbol(x3, Decl(mixinClassesMembers.ts, 30, 7)) ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) +>x3 : Symbol(x3, Decl(mixinClassesMembers.ts, 29, 7)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) let x4 = new Mixed2(42); ->x4 : Symbol(x4, Decl(mixinClassesMembers.ts, 31, 7)) ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) +>x4 : Symbol(x4, Decl(mixinClassesMembers.ts, 30, 7)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) let x5 = new Mixed3("hello"); ->x5 : Symbol(x5, Decl(mixinClassesMembers.ts, 32, 7)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) +>x5 : Symbol(x5, Decl(mixinClassesMembers.ts, 31, 7)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) let x6 = new Mixed3(42); ->x6 : Symbol(x6, Decl(mixinClassesMembers.ts, 33, 7)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) +>x6 : Symbol(x6, Decl(mixinClassesMembers.ts, 32, 7)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) let x7 = new Mixed4("hello"); ->x7 : Symbol(x7, Decl(mixinClassesMembers.ts, 34, 7)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) +>x7 : Symbol(x7, Decl(mixinClassesMembers.ts, 33, 7)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) let x8 = new Mixed4(42); ->x8 : Symbol(x8, Decl(mixinClassesMembers.ts, 35, 7)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) +>x8 : Symbol(x8, Decl(mixinClassesMembers.ts, 34, 7)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) let x9 = new Mixed5(); ->x9 : Symbol(x9, Decl(mixinClassesMembers.ts, 36, 7)) ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) +>x9 : Symbol(x9, Decl(mixinClassesMembers.ts, 35, 7)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) } function f2() { ->f2 : Symbol(f2, Decl(mixinClassesMembers.ts, 37, 1)) +>f2 : Symbol(f2, Decl(mixinClassesMembers.ts, 36, 1)) let x = new Mixed1("hello"); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 40, 7)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 39, 7)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) x.a; ->x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 40, 7)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 39, 7)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 40, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 39, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) Mixed1.p; ->Mixed1.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed1.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) } function f3() { ->f3 : Symbol(f3, Decl(mixinClassesMembers.ts, 44, 1)) +>f3 : Symbol(f3, Decl(mixinClassesMembers.ts, 43, 1)) let x = new Mixed2("hello"); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 47, 7)) ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 46, 7)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) x.a; ->x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 47, 7)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 46, 7)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 47, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 46, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) Mixed2.p; ->Mixed2.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed2.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 21, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) } function f4() { ->f4 : Symbol(f4, Decl(mixinClassesMembers.ts, 51, 1)) +>f4 : Symbol(f4, Decl(mixinClassesMembers.ts, 50, 1)) let x = new Mixed3("hello"); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 53, 7)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) x.a; ->x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 53, 7)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 53, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) x.f(); ->x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 53, 7)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) Mixed3.p; ->Mixed3.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed3.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) Mixed3.f(); ->Mixed3.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) +>Mixed3.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) } function f5() { ->f5 : Symbol(f5, Decl(mixinClassesMembers.ts, 60, 1)) +>f5 : Symbol(f5, Decl(mixinClassesMembers.ts, 59, 1)) let x = new Mixed4("hello"); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 62, 7)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) x.a; ->x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 62, 7)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 62, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) x.f(); ->x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 62, 7)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) Mixed4.p; ->Mixed4.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed4.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) Mixed4.f(); ->Mixed4.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) ->Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) +>Mixed4.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) +>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 23, 13)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) } function f6() { ->f6 : Symbol(f6, Decl(mixinClassesMembers.ts, 69, 1)) +>f6 : Symbol(f6, Decl(mixinClassesMembers.ts, 68, 1)) let x = new Mixed5(); ->x : Symbol(x, Decl(mixinClassesMembers.ts, 72, 7)) ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 71, 7)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) x.p; ->x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 72, 7)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 71, 7)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) x.f(); ->x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) ->x : Symbol(x, Decl(mixinClassesMembers.ts, 72, 7)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) +>x : Symbol(x, Decl(mixinClassesMembers.ts, 71, 7)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) Mixed5.p; ->Mixed5.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14)) +>Mixed5.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 14)) Mixed5.f(); ->Mixed5.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) ->Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16)) +>Mixed5.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) +>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 24, 13)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 16)) } class C2 extends Mixed1 { ->C2 : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1)) ->Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13)) +>C2 : Symbol(C2, Decl(mixinClassesMembers.ts, 76, 1)) +>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 20, 13)) constructor() { super("hello"); this.a; ->this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->this : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>this : Symbol(C2, Decl(mixinClassesMembers.ts, 76, 1)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) this.b; ->this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) ->this : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1)) ->b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) +>this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) +>this : Symbol(C2, Decl(mixinClassesMembers.ts, 76, 1)) +>b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) this.p; ->this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->this : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>this : Symbol(C2, Decl(mixinClassesMembers.ts, 76, 1)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) } } class C3 extends Mixed3 { ->C3 : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13)) +>C3 : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 22, 13)) constructor() { super(42); this.a; ->this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) ->this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18)) +>this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) +>this : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 0, 18)) this.b; ->this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) ->this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21)) +>this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) +>this : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 1, 21)) this.p; ->this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) ->this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32)) +>this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) +>this : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 9, 32)) this.f(); ->this.f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 95, 5)) ->this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1)) ->f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 95, 5)) +>this.f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 94, 5)) +>this : Symbol(C3, Decl(mixinClassesMembers.ts, 85, 1)) +>f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 94, 5)) } f() { return super.f(); } ->f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 95, 5)) ->super.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) ->f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32)) +>f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 94, 5)) +>super.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) +>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 15, 32)) } diff --git a/tests/baselines/reference/mixinClassesMembers.types b/tests/baselines/reference/mixinClassesMembers.types index c8b291754158d..d53d50d34cbf9 100644 --- a/tests/baselines/reference/mixinClassesMembers.types +++ b/tests/baselines/reference/mixinClassesMembers.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/mixinClassesMembers.ts === - declare class C1 { >C1 : C1 diff --git a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.js b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.js index f7c4db2ff2abf..464e0c6f37be0 100644 --- a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.js +++ b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.js @@ -1,5 +1,4 @@ //// [modifierOnClassDeclarationMemberInFunction.ts] - function f() { class C { public baz = 1; diff --git a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.symbols b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.symbols index b41f51ffac7f8..757e2d165c607 100644 --- a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.symbols +++ b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.symbols @@ -1,18 +1,17 @@ === tests/cases/conformance/classes/classDeclarations/modifierOnClassDeclarationMemberInFunction.ts === - function f() { >f : Symbol(f, Decl(modifierOnClassDeclarationMemberInFunction.ts, 0, 0)) class C { ->C : Symbol(C, Decl(modifierOnClassDeclarationMemberInFunction.ts, 1, 14)) +>C : Symbol(C, Decl(modifierOnClassDeclarationMemberInFunction.ts, 0, 14)) public baz = 1; ->baz : Symbol(C.baz, Decl(modifierOnClassDeclarationMemberInFunction.ts, 2, 13)) +>baz : Symbol(C.baz, Decl(modifierOnClassDeclarationMemberInFunction.ts, 1, 13)) static foo() { } ->foo : Symbol(C.foo, Decl(modifierOnClassDeclarationMemberInFunction.ts, 3, 23)) +>foo : Symbol(C.foo, Decl(modifierOnClassDeclarationMemberInFunction.ts, 2, 23)) public bar() { } ->bar : Symbol(C.bar, Decl(modifierOnClassDeclarationMemberInFunction.ts, 4, 24)) +>bar : Symbol(C.bar, Decl(modifierOnClassDeclarationMemberInFunction.ts, 3, 24)) } } diff --git a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.types b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.types index 097383ee75e5e..cb6a64b09a6fe 100644 --- a/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.types +++ b/tests/baselines/reference/modifierOnClassDeclarationMemberInFunction.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/classDeclarations/modifierOnClassDeclarationMemberInFunction.ts === - function f() { >f : () => void diff --git a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.js b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.js index 211c80bcce853..3403a376d42dd 100644 --- a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.js +++ b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.js @@ -1,5 +1,4 @@ //// [modifierOnClassExpressionMemberInFunction.ts] - function g() { var x = class C { public prop1 = 1; diff --git a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols index d603d96dcda60..680d9c4d78b46 100644 --- a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols +++ b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/classes/classExpressions/modifierOnClassExpressionMemberInFunction.ts === - function g() { >g : Symbol(g, Decl(modifierOnClassExpressionMemberInFunction.ts, 0, 0)) var x = class C { ->x : Symbol(x, Decl(modifierOnClassExpressionMemberInFunction.ts, 2, 7)) ->C : Symbol(C, Decl(modifierOnClassExpressionMemberInFunction.ts, 2, 11)) +>x : Symbol(x, Decl(modifierOnClassExpressionMemberInFunction.ts, 1, 7)) +>C : Symbol(C, Decl(modifierOnClassExpressionMemberInFunction.ts, 1, 11)) public prop1 = 1; ->prop1 : Symbol(C.prop1, Decl(modifierOnClassExpressionMemberInFunction.ts, 2, 21)) +>prop1 : Symbol(C.prop1, Decl(modifierOnClassExpressionMemberInFunction.ts, 1, 21)) private foo() { } ->foo : Symbol(C.foo, Decl(modifierOnClassExpressionMemberInFunction.ts, 3, 25)) +>foo : Symbol(C.foo, Decl(modifierOnClassExpressionMemberInFunction.ts, 2, 25)) static prop2 = 43; ->prop2 : Symbol(C.prop2, Decl(modifierOnClassExpressionMemberInFunction.ts, 4, 25)) +>prop2 : Symbol(C.prop2, Decl(modifierOnClassExpressionMemberInFunction.ts, 3, 25)) } } diff --git a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.types b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.types index 4f454754b2b86..707163e83f46d 100644 --- a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.types +++ b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/classExpressions/modifierOnClassExpressionMemberInFunction.ts === - function g() { >g : () => void diff --git a/tests/baselines/reference/modularizeLibrary_Dom.iterable.js b/tests/baselines/reference/modularizeLibrary_Dom.iterable.js index a448e8359a5c9..534173c8e5e12 100644 --- a/tests/baselines/reference/modularizeLibrary_Dom.iterable.js +++ b/tests/baselines/reference/modularizeLibrary_Dom.iterable.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_Dom.iterable.ts] - for (const element of document.getElementsByTagName("a")) { element.href; } diff --git a/tests/baselines/reference/modularizeLibrary_Dom.iterable.symbols b/tests/baselines/reference/modularizeLibrary_Dom.iterable.symbols index 478997ca63074..32cff5e42ad28 100644 --- a/tests/baselines/reference/modularizeLibrary_Dom.iterable.symbols +++ b/tests/baselines/reference/modularizeLibrary_Dom.iterable.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/modularizeLibrary_Dom.iterable.ts === - for (const element of document.getElementsByTagName("a")) { ->element : Symbol(element, Decl(modularizeLibrary_Dom.iterable.ts, 1, 10)) +>element : Symbol(element, Decl(modularizeLibrary_Dom.iterable.ts, 0, 10)) >document.getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) >document : Symbol(document, Decl(lib.dom.d.ts, --, --)) >getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) element.href; >element.href : Symbol(HTMLAnchorElement.href, Decl(lib.dom.d.ts, --, --)) ->element : Symbol(element, Decl(modularizeLibrary_Dom.iterable.ts, 1, 10)) +>element : Symbol(element, Decl(modularizeLibrary_Dom.iterable.ts, 0, 10)) >href : Symbol(HTMLAnchorElement.href, Decl(lib.dom.d.ts, --, --)) } diff --git a/tests/baselines/reference/modularizeLibrary_Dom.iterable.types b/tests/baselines/reference/modularizeLibrary_Dom.iterable.types index f9a58d554cf9b..e8656beb9859b 100644 --- a/tests/baselines/reference/modularizeLibrary_Dom.iterable.types +++ b/tests/baselines/reference/modularizeLibrary_Dom.iterable.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_Dom.iterable.ts === - for (const element of document.getElementsByTagName("a")) { >element : HTMLAnchorElement >document.getElementsByTagName("a") : NodeListOf diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt index 3668e7080fd9f..82bc36819a5f4 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt @@ -1,14 +1,13 @@ error TS2318: Cannot find global type 'Boolean'. error TS2318: Cannot find global type 'IArguments'. error TS2318: Cannot find global type 'Number'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts(4,12): error TS2693: 'Array' only refers to a type, but is being used as a value here. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts(3,12): error TS2693: 'Array' only refers to a type, but is being used as a value here. !!! error TS2318: Cannot find global type 'Boolean'. !!! error TS2318: Cannot find global type 'IArguments'. !!! error TS2318: Cannot find global type 'Number'. ==== tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts (1 errors) ==== - // Error missing basic JavaScript objects function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js index 61591a5f7e12f..9e7ecabf6f472 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts] - // Error missing basic JavaScript objects function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt index c8a69546ee038..80b8e345cde31 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt @@ -1,19 +1,18 @@ -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(5,18): error TS2339: Property 'from' does not exist on type 'ArrayConstructor'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(11,13): error TS2304: Cannot find name 'Map'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(18,5): error TS2339: Property 'name' does not exist on type '() => void'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(21,6): error TS2339: Property 'sign' does not exist on type 'Math'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(26,6): error TS2304: Cannot find name 'Symbol'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(30,18): error TS2304: Cannot find name 'Symbol'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(34,13): error TS2304: Cannot find name 'Proxy'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(37,1): error TS2304: Cannot find name 'Reflect'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(41,5): error TS2339: Property 'flags' does not exist on type 'RegExp'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(45,5): error TS2339: Property 'includes' does not exist on type 'string'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(48,9): error TS2304: Cannot find name 'Symbol'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(52,6): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(4,18): error TS2339: Property 'from' does not exist on type 'ArrayConstructor'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(10,13): error TS2304: Cannot find name 'Map'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(17,5): error TS2339: Property 'name' does not exist on type '() => void'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(20,6): error TS2339: Property 'sign' does not exist on type 'Math'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(25,6): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(29,18): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(33,13): error TS2304: Cannot find name 'Proxy'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(36,1): error TS2304: Cannot find name 'Reflect'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(40,5): error TS2339: Property 'flags' does not exist on type 'RegExp'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(44,5): error TS2339: Property 'includes' does not exist on type 'string'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(47,9): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(51,6): error TS2304: Cannot find name 'Symbol'. ==== tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts (12 errors) ==== - // All will be error from using ES6 features but only include ES5 library // Using Es6 array function f(x: number, y: number, z: number) { diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js index 257df4278fefc..79d8aac8bb906 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts] - // All will be error from using ES6 features but only include ES5 library // Using Es6 array function f(x: number, y: number, z: number) { diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt index f5a8b84ac29c6..7c0dc9a1cf2cb 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(8,1): error TS2322: Type 'false' is not assignable to type 'string'. -tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(8,3): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(7,1): error TS2322: Type 'false' is not assignable to type 'string'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(7,3): error TS2304: Cannot find name 'Symbol'. ==== tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts (2 errors) ==== - function f(x: number, y: number, z: number) { return Array.from(arguments); } diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js index e150560cc6a9d..ab85c912b4d04 100644 --- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts] - function f(x: number, y: number, z: number) { return Array.from(arguments); } diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js index b83efdce89040..8fdb55a0f26e7 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_NoErrorDuplicateLibOptions1.ts] - // Using Es6 array function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols index ccee4a59a705e..7572899356921 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -19,61 +18,61 @@ f(1, 2, 3); // no error // Using ES6 collection var m = new Map(); ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 8, 3)) >Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) m.clear(); >m.clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 8, 3)) >clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) // Using ES6 iterable m.keys(); >m.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 8, 3)) >keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) // Using ES6 function function Baz() { } ->Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 11, 9)) Baz.name; >Baz.name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) ->Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 11, 9)) >name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 generator function* gen() { ->gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 16, 9)) +>gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 15, 9)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 19, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 19, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 19, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 19, 7)) } } function* gen2() { ->gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 25, 1)) +>gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 24, 1)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 27, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 27, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 27, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 27, 7)) } } @@ -85,23 +84,23 @@ Math.sign(1); // Using ES6 object var o = { ->o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 38, 3)) a: 2, ->a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 39, 9)) +>a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 38, 9)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 41, 25)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 40, 25)) return false; } }; o.hasOwnProperty(Symbol.hasInstance); >o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 38, 3)) >hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) @@ -109,35 +108,35 @@ o.hasOwnProperty(Symbol.hasInstance); // Using ES6 promise async function out() { ->out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 44, 37)) return new Promise(function (resolve, reject) {}); >Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 49, 33)) ->reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 49, 41)) +>resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 48, 33)) +>reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 48, 41)) } declare var console: any; ->console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 51, 11)) out().then(() => { >out().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) ->out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 44, 37)) >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) console.log("Yea!"); ->console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 51, 11)) }); // Using Es6 proxy var t = {} ->t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 57, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 59, 3)) +>p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 58, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 57, 3)) // Using ES6 reflect Reflect.isExtensible({}); @@ -147,37 +146,37 @@ Reflect.isExtensible({}); // Using Es6 regexp var reg = new RegExp("/s"); ->reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 64, 3)) >RegExp : Symbol(RegExp, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) reg.flags; >reg.flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) ->reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 64, 3)) >flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 string var str = "Hello world"; ->str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 68, 3)) str.includes("hello", 0); >str.includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) ->str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 68, 3)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 symbol var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 73, 3)) +>s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 72, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) // Using ES6 wellknown-symbol const o1 = { ->o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 76, 5)) +>o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 75, 5)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 77, 25)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 76, 25)) return false; } diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types index 532ef5511fa85..7012b25ccbd46 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js index 32d7135916b21..21a8fa48b1f57 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_NoErrorDuplicateLibOptions2.ts] - // Using Es6 array function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols index 97c6852b50378..a98353eb07765 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -19,61 +18,61 @@ f(1, 2, 3); // no error // Using ES6 collection var m = new Map(); ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 8, 3)) >Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) m.clear(); >m.clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 8, 3)) >clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) // Using ES6 iterable m.keys(); >m.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 8, 3)) >keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) // Using ES6 function function Baz() { } ->Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 11, 9)) Baz.name; >Baz.name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) ->Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 11, 9)) >name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 generator function* gen() { ->gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 16, 9)) +>gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 15, 9)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 19, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 19, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 19, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 19, 7)) } } function* gen2() { ->gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 25, 1)) +>gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 24, 1)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 27, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 27, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 27, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 27, 7)) } } @@ -85,23 +84,23 @@ Math.sign(1); // Using ES6 object var o = { ->o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 38, 3)) a: 2, ->a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 39, 9)) +>a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 38, 9)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 41, 25)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 40, 25)) return false; } }; o.hasOwnProperty(Symbol.hasInstance); >o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 38, 3)) >hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) @@ -109,35 +108,35 @@ o.hasOwnProperty(Symbol.hasInstance); // Using ES6 promise async function out() { ->out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 44, 37)) return new Promise(function (resolve, reject) {}); >Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 49, 33)) ->reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 49, 41)) +>resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 48, 33)) +>reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 48, 41)) } declare var console: any; ->console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 51, 11)) out().then(() => { >out().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) ->out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 44, 37)) >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) console.log("Yea!"); ->console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 51, 11)) }); // Using Es6 proxy var t = {} ->t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 57, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 59, 3)) +>p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 58, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 57, 3)) // Using ES6 reflect Reflect.isExtensible({}); @@ -147,37 +146,37 @@ Reflect.isExtensible({}); // Using Es6 regexp var reg = new RegExp("/s"); ->reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 64, 3)) >RegExp : Symbol(RegExp, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) reg.flags; >reg.flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) ->reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 64, 3)) >flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 string var str = "Hello world"; ->str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 68, 3)) str.includes("hello", 0); >str.includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) ->str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 68, 3)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 symbol var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 73, 3)) +>s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 72, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) // Using ES6 wellknown-symbol const o1 = { ->o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 76, 5)) +>o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 75, 5)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 77, 25)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 76, 25)) return false; } diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types index 304b9411bff49..781e33e850aba 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js index d0de3c93da0d1..093f3bde8683a 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_TargetES5UsingES6Lib.ts] - // Using Es6 array function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols index 5aae1a6cb2f5a..c42e7a20374c9 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -19,61 +18,61 @@ f(1, 2, 3); // no error // Using ES6 collection var m = new Map(); ->m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 8, 3)) >Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) m.clear(); >m.clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 8, 3)) >clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) // Using ES6 iterable m.keys(); >m.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 8, 3)) >keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) // Using ES6 function function Baz() { } ->Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 11, 9)) Baz.name; >Baz.name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) ->Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 11, 9)) >name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 generator function* gen() { ->gen : Symbol(gen, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 16, 9)) +>gen : Symbol(gen, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 15, 9)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 19, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 19, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 19, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 19, 7)) } } function* gen2() { ->gen2 : Symbol(gen2, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 25, 1)) +>gen2 : Symbol(gen2, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 24, 1)) let i = 0; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 27, 7)) while (i < 10) { ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 27, 7)) yield i; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 27, 7)) i++; ->i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 27, 7)) } } @@ -85,23 +84,23 @@ Math.sign(1); // Using ES6 object var o = { ->o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 38, 3)) a: 2, ->a : Symbol(a, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 39, 9)) +>a : Symbol(a, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 38, 9)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 41, 25)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 40, 25)) return false; } }; o.hasOwnProperty(Symbol.hasInstance); >o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 39, 3)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 38, 3)) >hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) @@ -109,35 +108,35 @@ o.hasOwnProperty(Symbol.hasInstance); // Using ES6 promise async function out() { ->out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 44, 37)) return new Promise(function (resolve, reject) {}); >Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->resolve : Symbol(resolve, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 49, 33)) ->reject : Symbol(reject, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 49, 41)) +>resolve : Symbol(resolve, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 48, 33)) +>reject : Symbol(reject, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 48, 41)) } declare var console: any; ->console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 51, 11)) out().then(() => { >out().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) ->out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 45, 37)) +>out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 44, 37)) >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) console.log("Yea!"); ->console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 52, 11)) +>console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 51, 11)) }); // Using Es6 proxy var t = {} ->t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 57, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 59, 3)) +>p : Symbol(p, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 58, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 58, 3)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 57, 3)) // Using ES6 reflect Reflect.isExtensible({}); @@ -147,37 +146,37 @@ Reflect.isExtensible({}); // Using Es6 regexp var reg = new RegExp("/s"); ->reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 64, 3)) >RegExp : Symbol(RegExp, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) reg.flags; >reg.flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) ->reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 65, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 64, 3)) >flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 string var str = "Hello world"; ->str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 68, 3)) str.includes("hello", 0); >str.includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) ->str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 69, 3)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 68, 3)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 symbol var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 73, 3)) +>s : Symbol(s, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 72, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) // Using ES6 wellknown-symbol const o1 = { ->o1 : Symbol(o1, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 76, 5)) +>o1 : Symbol(o1, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 75, 5)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 77, 25)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 76, 25)) return false; } diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types index 28ceac3ac91b6..54c6958dcccda 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js index 137bd1063b8a5..7272057499e5b 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_TargetES6UsingES6Lib.ts] - // Using Es6 array function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols index 568c87d928fc4..42aa9ad1d875b 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -19,27 +18,27 @@ f(1, 2, 3); // no error // Using ES6 collection var m = new Map(); ->m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 8, 3)) >Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --)) m.clear(); >m.clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 8, 3)) >clear : Symbol(Map.clear, Decl(lib.es2015.collection.d.ts, --, --)) // Using ES6 iterable m.keys(); >m.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) ->m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 9, 3)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 8, 3)) >keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) // Using ES6 function function Baz() { } ->Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 11, 9)) Baz.name; >Baz.name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) ->Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 12, 9)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 11, 9)) >name : Symbol(Function.name, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 math @@ -50,23 +49,23 @@ Math.sign(1); // Using ES6 object var o = { ->o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 22, 3)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 21, 3)) a: 2, ->a : Symbol(a, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 22, 9)) +>a : Symbol(a, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 21, 9)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 24, 25)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 23, 25)) return false; } }; o.hasOwnProperty(Symbol.hasInstance); >o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 22, 3)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 21, 3)) >hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) @@ -74,12 +73,12 @@ o.hasOwnProperty(Symbol.hasInstance); // Using Es6 proxy var t = {} ->t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 31, 3)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 30, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 32, 3)) +>p : Symbol(p, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 31, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 31, 3)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 30, 3)) // Using ES6 reflect Reflect.isExtensible({}); @@ -89,37 +88,37 @@ Reflect.isExtensible({}); // Using Es6 regexp var reg = new RegExp("/s"); ->reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 38, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 37, 3)) >RegExp : Symbol(RegExp, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) reg.flags; >reg.flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) ->reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 38, 3)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 37, 3)) >flags : Symbol(RegExp.flags, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 string var str = "Hello world"; ->str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 42, 3)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 41, 3)) str.includes("hello", 0); >str.includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) ->str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 42, 3)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 41, 3)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) // Using ES6 symbol var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 46, 3)) +>s : Symbol(s, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 45, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) // Using ES6 wellknown-symbol const o1 = { ->o1 : Symbol(o1, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 49, 5)) +>o1 : Symbol(o1, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 48, 5)) [Symbol.hasInstance](value: any) { >Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) ->value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 50, 25)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 49, 25)) return false; } diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types index c1005cadca6b4..9dd896bc9e6f4 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts === - // Using Es6 array function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js index 29e0afc711c6b..04f4c584ff8a2 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_UsingES5LibAndES6ArrayLib.ts] - // No error function f(x: number, y: number, z: number) { return Array.from(arguments); diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols index 90a88d4fbaa70..bac3a49930d09 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts === - // No error function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 2, 11)) ->y : Symbol(y, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 2, 21)) ->z : Symbol(z, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 2, 32)) +>x : Symbol(x, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 1, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types index b7ab82ffb7ddc..c5368e33a3ca7 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts === - // No error function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js index 892bc688524bb..7fac1a80cde34 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts] - var s = Symbol(); var t = {}; var p = new Proxy(t, {}); diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols index e6f7584c471ac..0291ddef9c9f7 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts === - var s = Symbol(); ->s : Symbol(s, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 1, 3)) +>s : Symbol(s, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 0, 3)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) var t = {}; ->t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 2, 3)) +>t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 1, 3)) var p = new Proxy(t, {}); ->p : Symbol(p, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 3, 3)) +>p : Symbol(p, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 2, 3)) >Proxy : Symbol(Proxy, Decl(lib.es2015.proxy.d.ts, --, --)) ->t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 2, 3)) +>t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 1, 3)) Reflect.ownKeys({}); >Reflect.ownKeys : Symbol(Reflect.ownKeys, Decl(lib.es2015.reflect.d.ts, --, --)) @@ -18,16 +17,16 @@ Reflect.ownKeys({}); >ownKeys : Symbol(Reflect.ownKeys, Decl(lib.es2015.reflect.d.ts, --, --)) function* idGen() { ->idGen : Symbol(idGen, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 5, 20)) +>idGen : Symbol(idGen, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 4, 20)) let i = 10; ->i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 8, 7)) +>i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 7, 7)) while (i < 20) { ->i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 8, 7)) +>i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 7, 7)) yield i + 2; ->i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 8, 7)) +>i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 7, 7)) } } diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types index cceb9a1925e4a..281faddbc5233 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts === - var s = Symbol(); >s : symbol >Symbol() : symbol diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js index 7755fc72ce8f2..fdb1416993cf1 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js @@ -1,5 +1,4 @@ //// [modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts] - function f(x: number, y: number, z: number) { return Array.from(arguments); } diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols index 83ae1ac5f0851..d63c8e72e68ae 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts === - function f(x: number, y: number, z: number) { >f : Symbol(f, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 0)) ->x : Symbol(x, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 1, 11)) ->y : Symbol(y, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 1, 21)) ->z : Symbol(z, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 1, 32)) +>x : Symbol(x, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 11)) +>y : Symbol(y, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 21)) +>z : Symbol(z, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 32)) return Array.from(arguments); >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) @@ -17,10 +16,10 @@ f(1, 2, 3); // no error >f : Symbol(f, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 0)) let a = ['c', 'd']; ->a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 6, 3)) +>a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 5, 3)) a[Symbol.isConcatSpreadable] = false; ->a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 6, 3)) +>a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 5, 3)) >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --)) >isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types index 3515b6dc55da0..95144f1fd7a62 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts === - function f(x: number, y: number, z: number) { >f : (x: number, y: number, z: number) => any[] >x : number diff --git a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.js b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.js index a92cf5093e34e..949a30efc8fca 100644 --- a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.js +++ b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationCollidingNamesInAugmentation1.ts] //// //// [map1.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols index ce701a7c59d77..88a610901edef 100644 --- a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols +++ b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/map1.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map1.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map1.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map1.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map1.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface I {x0} ->I : Symbol(I, Decl(map1.ts, 5, 31), Decl(map2.ts, 4, 31)) ->x0 : Symbol(I.x0, Decl(map1.ts, 6, 17)) +>I : Symbol(I, Decl(map1.ts, 4, 31), Decl(map2.ts, 4, 31)) +>x0 : Symbol(I.x0, Decl(map1.ts, 5, 17)) } === tests/cases/compiler/map2.ts === @@ -25,7 +24,7 @@ import { Observable } from "./observable" declare module "./observable" { interface I {x1} ->I : Symbol(I, Decl(map1.ts, 5, 31), Decl(map2.ts, 4, 31)) +>I : Symbol(I, Decl(map1.ts, 4, 31), Decl(map2.ts, 4, 31)) >x1 : Symbol(I.x1, Decl(map2.ts, 5, 17)) } diff --git a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.types b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.types index e87560c6a3d1e..a6069712269bf 100644 --- a/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.types +++ b/tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map1.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.js b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.js index 7775930684556..818c49c9edf8f 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.js +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationDeclarationEmit1.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.symbols b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.symbols index 17e31591be00b..5f619a0cdf474 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.symbols +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someAnotherValue: number; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } export namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someValue: number; >someValue : Symbol(someValue, Decl(observable.ts, 5, 7)) @@ -65,9 +64,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types index 6c693b2b23bec..471e3ed38c3c8 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.js b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.js index 15ca6aaf806da..1dca750a6148f 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.js +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationDeclarationEmit2.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.symbols b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.symbols index 38a0506d179cc..ad2f467dbe773 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.symbols +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someAnotherValue: string; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } export namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) export let someValue: number; >someValue : Symbol(someValue, Decl(observable.ts, 5, 14)) @@ -65,9 +64,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) @@ -82,8 +81,8 @@ let z1 = Observable.someValue.toFixed(); let z2 = Observable.someAnotherValue.toLowerCase(); >z2 : Symbol(z2, Decl(main.ts, 6, 3)) >Observable.someAnotherValue.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >Observable : Symbol(Observable, Decl(main.ts, 0, 8)) ->someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types index ee302e6407ec9..bc17a6823f0aa 100644 --- a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types +++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationDisallowedExtensions.errors.txt b/tests/baselines/reference/moduleAugmentationDisallowedExtensions.errors.txt index 25577578ceb56..cacd821168cd8 100644 --- a/tests/baselines/reference/moduleAugmentationDisallowedExtensions.errors.txt +++ b/tests/baselines/reference/moduleAugmentationDisallowedExtensions.errors.txt @@ -1,20 +1,18 @@ +tests/cases/compiler/x.ts(17,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. +tests/cases/compiler/x.ts(17,26): error TS2307: Cannot find module './x0'. tests/cases/compiler/x.ts(18,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. -tests/cases/compiler/x.ts(18,26): error TS2307: Cannot find module './x0'. -tests/cases/compiler/x.ts(19,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. -tests/cases/compiler/x.ts(19,21): error TS2307: Cannot find module './x0'. +tests/cases/compiler/x.ts(18,21): error TS2307: Cannot find module './x0'. +tests/cases/compiler/x.ts(19,5): error TS2666: Exports and export assignments are not permitted in module augmentations. +tests/cases/compiler/x.ts(19,19): error TS2307: Cannot find module './x0'. tests/cases/compiler/x.ts(20,5): error TS2666: Exports and export assignments are not permitted in module augmentations. -tests/cases/compiler/x.ts(20,19): error TS2307: Cannot find module './x0'. -tests/cases/compiler/x.ts(21,5): error TS2666: Exports and export assignments are not permitted in module augmentations. -tests/cases/compiler/x.ts(21,21): error TS2307: Cannot find module './x0'. -tests/cases/compiler/x.ts(25,5): error TS2666: Exports and export assignments are not permitted in module augmentations. +tests/cases/compiler/x.ts(20,21): error TS2307: Cannot find module './x0'. +tests/cases/compiler/x.ts(24,5): error TS2666: Exports and export assignments are not permitted in module augmentations. ==== tests/cases/compiler/x0.ts (0 errors) ==== - export let a = 1; ==== tests/cases/compiler/x.ts (9 errors) ==== - namespace N1 { export let x = 1; } diff --git a/tests/baselines/reference/moduleAugmentationDisallowedExtensions.js b/tests/baselines/reference/moduleAugmentationDisallowedExtensions.js index c29bed68e5137..02e2fb313c470 100644 --- a/tests/baselines/reference/moduleAugmentationDisallowedExtensions.js +++ b/tests/baselines/reference/moduleAugmentationDisallowedExtensions.js @@ -1,11 +1,9 @@ //// [tests/cases/compiler/moduleAugmentationDisallowedExtensions.ts] //// //// [x0.ts] - export let a = 1; //// [x.ts] - namespace N1 { export let x = 1; } diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.js b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.js index d6857a28ef162..1ef8a7cd15414 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.js +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationExtendAmbientModule1.ts] //// //// [map.ts] - import { Observable } from "observable" (Observable.prototype).map = function() { } @@ -26,7 +25,6 @@ declare module "observable" { } //// [main.ts] - /// import { Observable } from "observable" import "./map"; diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.symbols b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.symbols index 62ac82b695319..3a632fce46127 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.symbols +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.symbols @@ -1,72 +1,70 @@ === tests/cases/compiler/main.ts === - /// import { Observable } from "observable" ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) import "./map"; let x: Observable; ->x : Symbol(x, Decl(main.ts, 5, 3)) ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>x : Symbol(x, Decl(main.ts, 4, 3)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) let y = x.map(x => x + 1); ->y : Symbol(y, Decl(main.ts, 6, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->x : Symbol(x, Decl(main.ts, 5, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->x : Symbol(x, Decl(main.ts, 6, 14)) ->x : Symbol(x, Decl(main.ts, 6, 14)) +>y : Symbol(y, Decl(main.ts, 5, 3)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>x : Symbol(x, Decl(main.ts, 4, 3)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>x : Symbol(x, Decl(main.ts, 5, 14)) +>x : Symbol(x, Decl(main.ts, 5, 14)) === tests/cases/compiler/map.ts === - import { Observable } from "observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) let someAnotherValue: number; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.d.ts === declare module "observable" { class Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.d.ts, 1, 25)) >pred : Symbol(pred, Decl(observable.d.ts, 2, 15)) >e : Symbol(e, Decl(observable.d.ts, 2, 22)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) let someValue: number; >someValue : Symbol(someValue, Decl(observable.d.ts, 5, 11)) diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types index 6c2c8c8e781ae..f27a85de25a2b 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/main.ts === - /// import { Observable } from "observable" >Observable : typeof Observable @@ -23,7 +22,6 @@ let y = x.map(x => x + 1); >1 : 1 === tests/cases/compiler/map.ts === - import { Observable } from "observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.js b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.js index eee03576336ff..23e61952e30be 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.js +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationExtendAmbientModule2.ts] //// //// [map.ts] - import { Observable } from "observable" (Observable.prototype).map = function() { } @@ -26,7 +25,6 @@ declare module "observable" { } //// [main.ts] - /// import { Observable } from "observable" import "./map"; diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.symbols b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.symbols index bbd3b6e5f791e..c7bf49202081b 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.symbols +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.symbols @@ -1,88 +1,86 @@ === tests/cases/compiler/main.ts === - /// import { Observable } from "observable" ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) import "./map"; let x: Observable; ->x : Symbol(x, Decl(main.ts, 5, 3)) ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>x : Symbol(x, Decl(main.ts, 4, 3)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) let y = x.map(x => x + 1); ->y : Symbol(y, Decl(main.ts, 6, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->x : Symbol(x, Decl(main.ts, 5, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->x : Symbol(x, Decl(main.ts, 6, 14)) ->x : Symbol(x, Decl(main.ts, 6, 14)) +>y : Symbol(y, Decl(main.ts, 5, 3)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>x : Symbol(x, Decl(main.ts, 4, 3)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>x : Symbol(x, Decl(main.ts, 5, 14)) +>x : Symbol(x, Decl(main.ts, 5, 14)) let z1 = Observable.someValue.toFixed(); ->z1 : Symbol(z1, Decl(main.ts, 7, 3)) +>z1 : Symbol(z1, Decl(main.ts, 6, 3)) >Observable.someValue.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >Observable.someValue : Symbol(Observable.someValue, Decl(observable.d.ts, 5, 18)) ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) >someValue : Symbol(Observable.someValue, Decl(observable.d.ts, 5, 18)) >toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) let z2 = Observable.someAnotherValue.toLowerCase(); ->z2 : Symbol(z2, Decl(main.ts, 8, 3)) +>z2 : Symbol(z2, Decl(main.ts, 7, 3)) >Observable.someAnotherValue.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) ->Observable : Symbol(Observable, Decl(main.ts, 2, 8)) ->someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) +>Observable : Symbol(Observable, Decl(main.ts, 1, 8)) +>someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) === tests/cases/compiler/map.ts === - import { Observable } from "observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) let someAnotherValue: string; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.d.ts === declare module "observable" { class Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.d.ts, 1, 25)) >pred : Symbol(pred, Decl(observable.d.ts, 2, 15)) >e : Symbol(e, Decl(observable.d.ts, 2, 22)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.d.ts, 1, 21), Decl(map.ts, 5, 25)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 5, 29), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.d.ts, 0, 29), Decl(observable.d.ts, 3, 5), Decl(map.ts, 4, 29), Decl(map.ts, 7, 5)) export let someValue: number; >someValue : Symbol(someValue, Decl(observable.d.ts, 5, 18)) diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types index b938cf9944e45..2c82dcbf84902 100644 --- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types +++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/main.ts === - /// import { Observable } from "observable" >Observable : typeof Observable @@ -41,7 +40,6 @@ let z2 = Observable.someAnotherValue.toLowerCase(); >toLowerCase : () => string === tests/cases/compiler/map.ts === - import { Observable } from "observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule1.js b/tests/baselines/reference/moduleAugmentationExtendFileModule1.js index 9d15f3fe387fd..85b30f4d0027f 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule1.js +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationExtendFileModule1.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule1.symbols b/tests/baselines/reference/moduleAugmentationExtendFileModule1.symbols index 17e31591be00b..5f619a0cdf474 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule1.symbols +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule1.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someAnotherValue: number; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } export namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someValue: number; >someValue : Symbol(someValue, Decl(observable.ts, 5, 7)) @@ -65,9 +64,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule1.types b/tests/baselines/reference/moduleAugmentationExtendFileModule1.types index 6c693b2b23bec..471e3ed38c3c8 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule1.types +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule2.js b/tests/baselines/reference/moduleAugmentationExtendFileModule2.js index 072c62862e3bc..4c67c63d1bb78 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule2.js +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationExtendFileModule2.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule2.symbols b/tests/baselines/reference/moduleAugmentationExtendFileModule2.symbols index 38a0506d179cc..ad2f467dbe773 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule2.symbols +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule2.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) let someAnotherValue: string; ->someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(someAnotherValue, Decl(map.ts, 9, 11)) } } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } export namespace Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 5, 31), Decl(map.ts, 8, 5)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(observable.ts, 2, 1), Decl(map.ts, 4, 31), Decl(map.ts, 7, 5)) export let someValue: number; >someValue : Symbol(someValue, Decl(observable.ts, 5, 14)) @@ -65,9 +64,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) @@ -82,8 +81,8 @@ let z1 = Observable.someValue.toFixed(); let z2 = Observable.someAnotherValue.toLowerCase(); >z2 : Symbol(z2, Decl(main.ts, 6, 3)) >Observable.someAnotherValue.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>Observable.someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >Observable : Symbol(Observable, Decl(main.ts, 0, 8)) ->someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 10, 11)) +>someAnotherValue : Symbol(Observable.someAnotherValue, Decl(map.ts, 9, 11)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule2.types b/tests/baselines/reference/moduleAugmentationExtendFileModule2.types index ee302e6407ec9..bc17a6823f0aa 100644 --- a/tests/baselines/reference/moduleAugmentationExtendFileModule2.types +++ b/tests/baselines/reference/moduleAugmentationExtendFileModule2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationGlobal1.js b/tests/baselines/reference/moduleAugmentationGlobal1.js index 2ef6441692f40..ae4042768e800 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal1.js +++ b/tests/baselines/reference/moduleAugmentationGlobal1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationGlobal1.ts] //// //// [f1.ts] - export class A {x: number;} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationGlobal1.symbols b/tests/baselines/reference/moduleAugmentationGlobal1.symbols index 53cc4500e07b0..1dcb80409b7c4 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal1.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal1.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/f1.ts === - export class A {x: number;} >A : Symbol(A, Decl(f1.ts, 0, 0)) ->x : Symbol(A.x, Decl(f1.ts, 1, 16)) +>x : Symbol(A.x, Decl(f1.ts, 0, 16)) === tests/cases/compiler/f2.ts === import {A} from "./f1"; @@ -27,9 +26,9 @@ let x = [1]; let y = x.getA().x; >y : Symbol(y, Decl(f2.ts, 10, 3)) ->x.getA().x : Symbol(A.x, Decl(f1.ts, 1, 16)) +>x.getA().x : Symbol(A.x, Decl(f1.ts, 0, 16)) >x.getA : Symbol(Array.getA, Decl(f2.ts, 4, 24)) >x : Symbol(x, Decl(f2.ts, 9, 3)) >getA : Symbol(Array.getA, Decl(f2.ts, 4, 24)) ->x : Symbol(A.x, Decl(f1.ts, 1, 16)) +>x : Symbol(A.x, Decl(f1.ts, 0, 16)) diff --git a/tests/baselines/reference/moduleAugmentationGlobal1.types b/tests/baselines/reference/moduleAugmentationGlobal1.types index 48ed21e21457c..fff55461b7d64 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal1.types +++ b/tests/baselines/reference/moduleAugmentationGlobal1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {x: number;} >A : A >x : number diff --git a/tests/baselines/reference/moduleAugmentationGlobal2.js b/tests/baselines/reference/moduleAugmentationGlobal2.js index 1806ceae9a192..28f6d3babf048 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal2.js +++ b/tests/baselines/reference/moduleAugmentationGlobal2.js @@ -1,10 +1,8 @@ //// [tests/cases/compiler/moduleAugmentationGlobal2.ts] //// //// [f1.ts] - export class A {}; //// [f2.ts] - // change the shape of Array import {A} from "./f1"; diff --git a/tests/baselines/reference/moduleAugmentationGlobal2.symbols b/tests/baselines/reference/moduleAugmentationGlobal2.symbols index 0e6d8a6024de8..b69e4eed01371 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal2.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal2.symbols @@ -1,34 +1,32 @@ === tests/cases/compiler/f1.ts === - export class A {}; >A : Symbol(A, Decl(f1.ts, 0, 0)) === tests/cases/compiler/f2.ts === - // change the shape of Array import {A} from "./f1"; ->A : Symbol(A, Decl(f2.ts, 2, 8)) +>A : Symbol(A, Decl(f2.ts, 1, 8)) declare global { ->global : Symbol(global, Decl(f2.ts, 2, 23)) +>global : Symbol(global, Decl(f2.ts, 1, 23)) interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(f2.ts, 4, 16)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(f2.ts, 5, 20)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(f2.ts, 3, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(f2.ts, 4, 20)) getCountAsString(): string; ->getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) } } let x = [1]; ->x : Symbol(x, Decl(f2.ts, 10, 3)) +>x : Symbol(x, Decl(f2.ts, 9, 3)) let y = x.getCountAsString().toLowerCase(); ->y : Symbol(y, Decl(f2.ts, 11, 3)) +>y : Symbol(y, Decl(f2.ts, 10, 3)) >x.getCountAsString().toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->x.getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) ->x : Symbol(x, Decl(f2.ts, 10, 3)) ->getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>x.getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) +>x : Symbol(x, Decl(f2.ts, 9, 3)) +>getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/moduleAugmentationGlobal2.types b/tests/baselines/reference/moduleAugmentationGlobal2.types index f80f0ec7c72c0..ef6239e11764c 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal2.types +++ b/tests/baselines/reference/moduleAugmentationGlobal2.types @@ -1,10 +1,8 @@ === tests/cases/compiler/f1.ts === - export class A {}; >A : A === tests/cases/compiler/f2.ts === - // change the shape of Array import {A} from "./f1"; >A : typeof A diff --git a/tests/baselines/reference/moduleAugmentationGlobal3.js b/tests/baselines/reference/moduleAugmentationGlobal3.js index 9cb08f2b866f4..d744d3017b905 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal3.js +++ b/tests/baselines/reference/moduleAugmentationGlobal3.js @@ -1,10 +1,8 @@ //// [tests/cases/compiler/moduleAugmentationGlobal3.ts] //// //// [f1.ts] - export class A {}; //// [f2.ts] - // change the shape of Array import {A} from "./f1"; diff --git a/tests/baselines/reference/moduleAugmentationGlobal3.symbols b/tests/baselines/reference/moduleAugmentationGlobal3.symbols index 1521fbb6e3488..f572214ad9135 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal3.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal3.symbols @@ -1,23 +1,21 @@ === tests/cases/compiler/f1.ts === - export class A {}; >A : Symbol(A, Decl(f1.ts, 0, 0)) === tests/cases/compiler/f2.ts === - // change the shape of Array import {A} from "./f1"; ->A : Symbol(A, Decl(f2.ts, 2, 8)) +>A : Symbol(A, Decl(f2.ts, 1, 8)) declare global { ->global : Symbol(global, Decl(f2.ts, 2, 23)) +>global : Symbol(global, Decl(f2.ts, 1, 23)) interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(f2.ts, 4, 16)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(f2.ts, 5, 20)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(f2.ts, 3, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(f2.ts, 4, 20)) getCountAsString(): string; ->getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) } } @@ -30,8 +28,8 @@ let x = [1]; let y = x.getCountAsString().toLowerCase(); >y : Symbol(y, Decl(f3.ts, 3, 3)) >x.getCountAsString().toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) ->x.getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>x.getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) >x : Symbol(x, Decl(f3.ts, 2, 3)) ->getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 5, 24)) +>getCountAsString : Symbol(Array.getCountAsString, Decl(f2.ts, 4, 24)) >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/moduleAugmentationGlobal3.types b/tests/baselines/reference/moduleAugmentationGlobal3.types index 3b9ed24a452b2..fa1ecf6332e66 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal3.types +++ b/tests/baselines/reference/moduleAugmentationGlobal3.types @@ -1,10 +1,8 @@ === tests/cases/compiler/f1.ts === - export class A {}; >A : A === tests/cases/compiler/f2.ts === - // change the shape of Array import {A} from "./f1"; >A : typeof A diff --git a/tests/baselines/reference/moduleAugmentationGlobal4.js b/tests/baselines/reference/moduleAugmentationGlobal4.js index 194d06aeb80a7..a47e4c6673a2e 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal4.js +++ b/tests/baselines/reference/moduleAugmentationGlobal4.js @@ -1,13 +1,11 @@ //// [tests/cases/compiler/moduleAugmentationGlobal4.ts] //// //// [f1.ts] - declare global { interface Something {x} } export {}; //// [f2.ts] - declare global { interface Something {y} } diff --git a/tests/baselines/reference/moduleAugmentationGlobal4.symbols b/tests/baselines/reference/moduleAugmentationGlobal4.symbols index 6aaa587234b94..5a2ed5c76e716 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal4.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal4.symbols @@ -1,21 +1,19 @@ === tests/cases/compiler/f1.ts === - declare global { >global : Symbol(global, Decl(f1.ts, 0, 0)) interface Something {x} ->Something : Symbol(Something, Decl(f1.ts, 1, 16), Decl(f2.ts, 1, 16)) ->x : Symbol(Something.x, Decl(f1.ts, 2, 25)) +>Something : Symbol(Something, Decl(f1.ts, 0, 16), Decl(f2.ts, 0, 16)) +>x : Symbol(Something.x, Decl(f1.ts, 1, 25)) } export {}; === tests/cases/compiler/f2.ts === - declare global { >global : Symbol(global, Decl(f2.ts, 0, 0)) interface Something {y} ->Something : Symbol(Something, Decl(f1.ts, 1, 16), Decl(f2.ts, 1, 16)) ->y : Symbol(Something.y, Decl(f2.ts, 2, 25)) +>Something : Symbol(Something, Decl(f1.ts, 0, 16), Decl(f2.ts, 0, 16)) +>y : Symbol(Something.y, Decl(f2.ts, 1, 25)) } export {}; === tests/cases/compiler/f3.ts === diff --git a/tests/baselines/reference/moduleAugmentationGlobal4.types b/tests/baselines/reference/moduleAugmentationGlobal4.types index e3e780d69ffb3..f577b591694a4 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal4.types +++ b/tests/baselines/reference/moduleAugmentationGlobal4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - declare global { >global : any @@ -9,7 +8,6 @@ declare global { } export {}; === tests/cases/compiler/f2.ts === - declare global { >global : any diff --git a/tests/baselines/reference/moduleAugmentationGlobal5.js b/tests/baselines/reference/moduleAugmentationGlobal5.js index 43d8c6b958b16..55433fcf6d6b9 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal5.js +++ b/tests/baselines/reference/moduleAugmentationGlobal5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationGlobal5.ts] //// //// [f1.d.ts] - declare module "A" { global { interface Something {x} diff --git a/tests/baselines/reference/moduleAugmentationGlobal5.symbols b/tests/baselines/reference/moduleAugmentationGlobal5.symbols index 4c4693601e816..ad5ab1cd4cd53 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal5.symbols +++ b/tests/baselines/reference/moduleAugmentationGlobal5.symbols @@ -6,14 +6,13 @@ No type information for this code.import "B"; No type information for this code. No type information for this code. No type information for this code.=== tests/cases/compiler/f1.d.ts === - declare module "A" { global { ->global : Symbol(global, Decl(f1.d.ts, 1, 20)) +>global : Symbol(global, Decl(f1.d.ts, 0, 20)) interface Something {x} ->Something : Symbol(Something, Decl(f1.d.ts, 2, 12), Decl(f2.d.ts, 1, 12)) ->x : Symbol(Something.x, Decl(f1.d.ts, 3, 29)) +>Something : Symbol(Something, Decl(f1.d.ts, 1, 12), Decl(f2.d.ts, 1, 12)) +>x : Symbol(Something.x, Decl(f1.d.ts, 2, 29)) } } === tests/cases/compiler/f2.d.ts === @@ -22,7 +21,7 @@ declare module "B" { >global : Symbol(global, Decl(f2.d.ts, 0, 20)) interface Something {y} ->Something : Symbol(Something, Decl(f1.d.ts, 2, 12), Decl(f2.d.ts, 1, 12)) +>Something : Symbol(Something, Decl(f1.d.ts, 1, 12), Decl(f2.d.ts, 1, 12)) >y : Symbol(Something.y, Decl(f2.d.ts, 2, 29)) } } diff --git a/tests/baselines/reference/moduleAugmentationGlobal5.types b/tests/baselines/reference/moduleAugmentationGlobal5.types index b2e6139eb267f..8cb9fdeb3f94c 100644 --- a/tests/baselines/reference/moduleAugmentationGlobal5.types +++ b/tests/baselines/reference/moduleAugmentationGlobal5.types @@ -6,7 +6,6 @@ No type information for this code.import "B"; No type information for this code. No type information for this code. No type information for this code.=== tests/cases/compiler/f1.d.ts === - declare module "A" { global { >global : any diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports1.js b/tests/baselines/reference/moduleAugmentationImportsAndExports1.js index 66ce39e8d84a1..27d69dd181c7d 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports1.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports1.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports1.symbols b/tests/baselines/reference/moduleAugmentationImportsAndExports1.symbols index 84daab19bf579..db4af0fa34e9c 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports1.symbols +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : Symbol(A, Decl(f1.ts, 0, 0), Decl(f3.ts, 4, 23)) diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports1.types b/tests/baselines/reference/moduleAugmentationImportsAndExports1.types index 886a04b54ef6b..5ab340b3aed9a 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports1.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports2.errors.txt b/tests/baselines/reference/moduleAugmentationImportsAndExports2.errors.txt index 9c49d38572b60..5f57081357e8a 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports2.errors.txt +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports2.errors.txt @@ -11,7 +11,6 @@ tests/cases/compiler/f4.ts(5,11): error TS2339: Property 'foo' does not exist on ==== tests/cases/compiler/f1.ts (0 errors) ==== - export class A {} ==== tests/cases/compiler/f2.ts (0 errors) ==== diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports2.js b/tests/baselines/reference/moduleAugmentationImportsAndExports2.js index e79f2e5848482..32d7950574df1 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports2.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports2.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports3.errors.txt b/tests/baselines/reference/moduleAugmentationImportsAndExports3.errors.txt index c2c43c85af3a6..33732c0552f34 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports3.errors.txt +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports3.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/f3.ts(13,16): error TS4000: Import declaration 'C' is using ==== tests/cases/compiler/f1.ts (0 errors) ==== - export class A {} ==== tests/cases/compiler/f2.ts (0 errors) ==== diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports3.js b/tests/baselines/reference/moduleAugmentationImportsAndExports3.js index c7c13ea786117..12bcffd00f698 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports3.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports3.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports4.js b/tests/baselines/reference/moduleAugmentationImportsAndExports4.js index 9cdf76b90a557..041c2c71d093a 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports4.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports4.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports4.symbols b/tests/baselines/reference/moduleAugmentationImportsAndExports4.symbols index fd1ec87b2a274..a65f0e4f3392a 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports4.symbols +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports4.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : Symbol(A, Decl(f1.ts, 0, 0), Decl(f3.ts, 12, 23)) diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports4.types b/tests/baselines/reference/moduleAugmentationImportsAndExports4.types index 454dc5d27ecd5..1dc7a9da1e853 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports4.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports5.errors.txt b/tests/baselines/reference/moduleAugmentationImportsAndExports5.errors.txt index 5f783453888c3..962386c730adb 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports5.errors.txt +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports5.errors.txt @@ -3,7 +3,6 @@ tests/cases/compiler/f3.ts(11,12): error TS4000: Import declaration 'C' is using ==== tests/cases/compiler/f1.ts (0 errors) ==== - export class A {} ==== tests/cases/compiler/f2.ts (0 errors) ==== diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports5.js b/tests/baselines/reference/moduleAugmentationImportsAndExports5.js index c7f7990608ec2..25a3702db6414 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports5.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports5.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports6.js b/tests/baselines/reference/moduleAugmentationImportsAndExports6.js index 0f19e737ec5ba..3796d70f2d325 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports6.js +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationImportsAndExports6.ts] //// //// [f1.ts] - export class A {} //// [f2.ts] diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports6.symbols b/tests/baselines/reference/moduleAugmentationImportsAndExports6.symbols index 5c9be6d944853..5e4ead631bc50 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports6.symbols +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports6.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : Symbol(A, Decl(f1.ts, 0, 0), Decl(f3.ts, 12, 23)) diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports6.types b/tests/baselines/reference/moduleAugmentationImportsAndExports6.types index 0c201599b52a0..544514d2855a3 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports6.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/f1.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule1.js b/tests/baselines/reference/moduleAugmentationInAmbientModule1.js index 4cdef37a4f7cc..7bd3c93496c3a 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule1.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule1.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule1.ts] //// //// [O.d.ts] - - declare module "Observable" { class Observable {} } @@ -29,8 +27,8 @@ x.foo().x; //// [main.js] -/// "use strict"; +/// exports.__esModule = true; var x; x.foo().x; diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule1.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule1.symbols index 6d9c185ca0812..b4f22e07d4cfc 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule1.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule1.symbols @@ -9,37 +9,35 @@ let x: Observable; >Observable : Symbol(Observable, Decl(main.ts, 2, 8)) x.foo().x; ->x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 7, 15)) ->x.foo : Symbol(Observable.foo, Decl(O.d.ts, 13, 30)) +>x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) +>x.foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->foo : Symbol(Observable.foo, Decl(O.d.ts, 13, 30)) ->x : Symbol(Cls.x, Decl(O.d.ts, 7, 15)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) === tests/cases/compiler/O.d.ts === - - declare module "Observable" { class Observable {} ->Observable : Symbol(Observable, Decl(O.d.ts, 2, 29), Decl(O.d.ts, 12, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25)) } declare module "M" { class Cls { x: number } ->Cls : Symbol(Cls, Decl(O.d.ts, 6, 20)) ->x : Symbol(Cls.x, Decl(O.d.ts, 7, 15)) +>Cls : Symbol(Cls, Decl(O.d.ts, 4, 20)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) } declare module "Map" { import { Cls } from "M"; ->Cls : Symbol(Cls, Decl(O.d.ts, 11, 12)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 2, 29), Decl(O.d.ts, 12, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25)) foo(): Cls; ->foo : Symbol(Observable.foo, Decl(O.d.ts, 13, 30)) ->Cls : Symbol(Cls, Decl(O.d.ts, 11, 12)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) } } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule1.types b/tests/baselines/reference/moduleAugmentationInAmbientModule1.types index 0be2a787cb605..5c0d6cb29c64d 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule1.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule1.types @@ -17,8 +17,6 @@ x.foo().x; >x : number === tests/cases/compiler/O.d.ts === - - declare module "Observable" { class Observable {} >Observable : Observable diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule2.js b/tests/baselines/reference/moduleAugmentationInAmbientModule2.js index 536931ee61fbf..f3d276309ef27 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule2.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule2.ts] //// //// [O.d.ts] - declare module "Observable" { class Observable {} } @@ -29,8 +28,8 @@ x.foo().x; //// [main.js] -/// "use strict"; +/// exports.__esModule = true; require("Map"); var x; diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule2.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule2.symbols index 5bf797dcf0810..07758a584698d 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule2.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule2.symbols @@ -10,36 +10,35 @@ let x: Observable; >Observable : Symbol(Observable, Decl(main.ts, 2, 8)) x.foo().x; ->x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) ->x.foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) +>x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) +>x.foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) >x : Symbol(x, Decl(main.ts, 4, 3)) ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25)) } declare module "M" { class Cls { x: number } ->Cls : Symbol(Cls, Decl(O.d.ts, 5, 20)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>Cls : Symbol(Cls, Decl(O.d.ts, 4, 20)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) } declare module "Map" { import { Cls } from "M"; ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25)) foo(): Cls; ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) } } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule2.types b/tests/baselines/reference/moduleAugmentationInAmbientModule2.types index 31ea8904c2af9..e72a8b66fdb85 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule2.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule2.types @@ -18,7 +18,6 @@ x.foo().x; >x : number === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} >Observable : Observable diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule3.js b/tests/baselines/reference/moduleAugmentationInAmbientModule3.js index 37253ab7e5b40..3cedfd66d5deb 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule3.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule3.ts] //// //// [O.d.ts] - declare module "Observable" { class Observable {} } @@ -39,8 +38,8 @@ x.foo2().x2; //// [main.js] -/// "use strict"; +/// exports.__esModule = true; require("Map"); var x; diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule3.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule3.symbols index 2bde1316107df..6fd1f788377a9 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule3.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule3.symbols @@ -10,59 +10,58 @@ let x: Observable; >Observable : Symbol(Observable, Decl(main.ts, 2, 8)) x.foo().x; ->x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) ->x.foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) +>x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) +>x.foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) >x : Symbol(x, Decl(main.ts, 4, 3)) ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) x.foo2().x2; ->x.foo2().x2 : Symbol(Cls2.x2, Decl(O.d.ts, 19, 16)) ->x.foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 21, 30)) +>x.foo2().x2 : Symbol(Cls2.x2, Decl(O.d.ts, 18, 16)) +>x.foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 20, 30)) >x : Symbol(x, Decl(main.ts, 4, 3)) ->foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 21, 30)) ->x2 : Symbol(Cls2.x2, Decl(O.d.ts, 19, 16)) +>foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 20, 30)) +>x2 : Symbol(Cls2.x2, Decl(O.d.ts, 18, 16)) === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O.d.ts, 20, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O.d.ts, 19, 25)) } declare module "M" { class Cls { x: number } ->Cls : Symbol(Cls, Decl(O.d.ts, 5, 20)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>Cls : Symbol(Cls, Decl(O.d.ts, 4, 20)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) } declare module "Map" { import { Cls } from "M"; ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O.d.ts, 20, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O.d.ts, 19, 25)) foo(): Cls; ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) } } } declare module "Map" { class Cls2 { x2: number } ->Cls2 : Symbol(Cls2, Decl(O.d.ts, 18, 22)) ->x2 : Symbol(Cls2.x2, Decl(O.d.ts, 19, 16)) +>Cls2 : Symbol(Cls2, Decl(O.d.ts, 17, 22)) +>x2 : Symbol(Cls2.x2, Decl(O.d.ts, 18, 16)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O.d.ts, 20, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O.d.ts, 19, 25)) foo2(): Cls2; ->foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 21, 30)) ->Cls2 : Symbol(Cls2, Decl(O.d.ts, 18, 22)) +>foo2 : Symbol(Observable.foo2, Decl(O.d.ts, 20, 30)) +>Cls2 : Symbol(Cls2, Decl(O.d.ts, 17, 22)) } } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule3.types b/tests/baselines/reference/moduleAugmentationInAmbientModule3.types index 2cec5edc6bf8f..56dca6707e9f7 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule3.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule3.types @@ -26,7 +26,6 @@ x.foo2().x2; >x2 : number === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} >Observable : Observable diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule4.js b/tests/baselines/reference/moduleAugmentationInAmbientModule4.js index 0c861447b46a7..ab4ff1bc79f11 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule4.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule4.ts] //// //// [O.d.ts] - declare module "Observable" { class Observable {} } @@ -41,9 +40,9 @@ x.foo2().x2; //// [main.js] +"use strict"; /// /// -"use strict"; exports.__esModule = true; require("Map"); var x; diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule4.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule4.symbols index 6e01ff8a20416..5d19e07ebbb30 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule4.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule4.symbols @@ -11,11 +11,11 @@ let x: Observable; >Observable : Symbol(Observable, Decl(main.ts, 3, 8)) x.foo().x; ->x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) ->x.foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) +>x.foo().x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) +>x.foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) >x : Symbol(x, Decl(main.ts, 5, 3)) ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) x.foo2().x2; >x.foo2().x2 : Symbol(Cls2.x2, Decl(O2.d.ts, 1, 16)) @@ -25,29 +25,28 @@ x.foo2().x2; >x2 : Symbol(Cls2.x2, Decl(O2.d.ts, 1, 16)) === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O2.d.ts, 2, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O2.d.ts, 2, 25)) } declare module "M" { class Cls { x: number } ->Cls : Symbol(Cls, Decl(O.d.ts, 5, 20)) ->x : Symbol(Cls.x, Decl(O.d.ts, 6, 15)) +>Cls : Symbol(Cls, Decl(O.d.ts, 4, 20)) +>x : Symbol(Cls.x, Decl(O.d.ts, 5, 15)) } declare module "Map" { import { Cls } from "M"; ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O2.d.ts, 2, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O2.d.ts, 2, 25)) foo(): Cls; ->foo : Symbol(Observable.foo, Decl(O.d.ts, 12, 30)) ->Cls : Symbol(Cls, Decl(O.d.ts, 10, 12)) +>foo : Symbol(Observable.foo, Decl(O.d.ts, 11, 30)) +>Cls : Symbol(Cls, Decl(O.d.ts, 9, 12)) } } } @@ -60,7 +59,7 @@ declare module "Map" { module "Observable" { interface Observable { ->Observable : Symbol(Observable, Decl(O.d.ts, 1, 29), Decl(O.d.ts, 11, 25), Decl(O2.d.ts, 2, 25)) +>Observable : Symbol(Observable, Decl(O.d.ts, 0, 29), Decl(O.d.ts, 10, 25), Decl(O2.d.ts, 2, 25)) foo2(): Cls2; >foo2 : Symbol(Observable.foo2, Decl(O2.d.ts, 3, 30)) diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule4.types b/tests/baselines/reference/moduleAugmentationInAmbientModule4.types index 04791aef860f4..d8158cef6187f 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule4.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule4.types @@ -27,7 +27,6 @@ x.foo2().x2; >x2 : number === tests/cases/compiler/O.d.ts === - declare module "Observable" { class Observable {} >Observable : Observable diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule5.js b/tests/baselines/reference/moduleAugmentationInAmbientModule5.js index ac202784f43e8..4f99c79fa18e8 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule5.js +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationInAmbientModule5.ts] //// //// [array.d.ts] - declare module "A" { class A { x: number; } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule5.symbols b/tests/baselines/reference/moduleAugmentationInAmbientModule5.symbols index a8cc1a3412e0b..59d3002dd1c01 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule5.symbols +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule5.symbols @@ -7,34 +7,33 @@ let x = [1]; let y = x.getA().x; >y : Symbol(y, Decl(f.ts, 4, 3)) ->x.getA().x : Symbol(A.x, Decl(array.d.ts, 2, 13)) ->x.getA : Symbol(Array.getA, Decl(array.d.ts, 8, 28)) +>x.getA().x : Symbol(A.x, Decl(array.d.ts, 1, 13)) +>x.getA : Symbol(Array.getA, Decl(array.d.ts, 7, 28)) >x : Symbol(x, Decl(f.ts, 3, 3)) ->getA : Symbol(Array.getA, Decl(array.d.ts, 8, 28)) ->x : Symbol(A.x, Decl(array.d.ts, 2, 13)) +>getA : Symbol(Array.getA, Decl(array.d.ts, 7, 28)) +>x : Symbol(A.x, Decl(array.d.ts, 1, 13)) === tests/cases/compiler/array.d.ts === - declare module "A" { class A { x: number; } ->A : Symbol(A, Decl(array.d.ts, 1, 20)) ->x : Symbol(A.x, Decl(array.d.ts, 2, 13)) +>A : Symbol(A, Decl(array.d.ts, 0, 20)) +>x : Symbol(A.x, Decl(array.d.ts, 1, 13)) } declare module "array" { import {A} from "A"; ->A : Symbol(A, Decl(array.d.ts, 6, 12)) +>A : Symbol(A, Decl(array.d.ts, 5, 12)) global { ->global : Symbol(global, Decl(array.d.ts, 6, 24)) +>global : Symbol(global, Decl(array.d.ts, 5, 24)) interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(array.d.ts, 7, 12)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(array.d.ts, 8, 24)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(array.d.ts, 6, 12)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(array.d.ts, 7, 24)) getA(): A; ->getA : Symbol(Array.getA, Decl(array.d.ts, 8, 28)) ->A : Symbol(A, Decl(array.d.ts, 6, 12)) +>getA : Symbol(Array.getA, Decl(array.d.ts, 7, 28)) +>A : Symbol(A, Decl(array.d.ts, 5, 12)) } } } diff --git a/tests/baselines/reference/moduleAugmentationInAmbientModule5.types b/tests/baselines/reference/moduleAugmentationInAmbientModule5.types index d6d81f97a3a82..513bf35460d2e 100644 --- a/tests/baselines/reference/moduleAugmentationInAmbientModule5.types +++ b/tests/baselines/reference/moduleAugmentationInAmbientModule5.types @@ -17,7 +17,6 @@ let y = x.getA().x; >x : number === tests/cases/compiler/array.d.ts === - declare module "A" { class A { x: number; } >A : A diff --git a/tests/baselines/reference/moduleAugmentationNoNewNames.js b/tests/baselines/reference/moduleAugmentationNoNewNames.js index 4376c23a7f8f8..0887377bc5895 100644 --- a/tests/baselines/reference/moduleAugmentationNoNewNames.js +++ b/tests/baselines/reference/moduleAugmentationNoNewNames.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationNoNewNames.ts] //// //// [map.ts] - import { Observable } from "./observable" (Observable.prototype).map = function() { } diff --git a/tests/baselines/reference/moduleAugmentationNoNewNames.symbols b/tests/baselines/reference/moduleAugmentationNoNewNames.symbols index a340d3820a2f1..beb60f829721b 100644 --- a/tests/baselines/reference/moduleAugmentationNoNewNames.symbols +++ b/tests/baselines/reference/moduleAugmentationNoNewNames.symbols @@ -1,59 +1,58 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) (Observable.prototype).map = function() { } >Observable.prototype : Symbol(Observable.prototype) ->Observable : Symbol(Observable, Decl(map.ts, 1, 8)) +>Observable : Symbol(Observable, Decl(map.ts, 0, 8)) >prototype : Symbol(Observable.prototype) declare module "./observable" { interface Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 5, 31)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 4, 31)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) map(proj: (e:T) => U): Observable ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->proj : Symbol(proj, Decl(map.ts, 7, 15)) ->e : Symbol(e, Decl(map.ts, 7, 22)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->U : Symbol(U, Decl(map.ts, 7, 12)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 5, 31)) ->U : Symbol(U, Decl(map.ts, 7, 12)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>proj : Symbol(proj, Decl(map.ts, 6, 15)) +>e : Symbol(e, Decl(map.ts, 6, 22)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>U : Symbol(U, Decl(map.ts, 6, 12)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 4, 31)) +>U : Symbol(U, Decl(map.ts, 6, 12)) } class Bar {} ->Bar : Symbol(Bar, Decl(map.ts, 8, 5)) +>Bar : Symbol(Bar, Decl(map.ts, 7, 5)) let y: number, z: string; ->y : Symbol(y, Decl(map.ts, 10, 7)) ->z : Symbol(z, Decl(map.ts, 10, 18)) +>y : Symbol(y, Decl(map.ts, 9, 7)) +>z : Symbol(z, Decl(map.ts, 9, 18)) let {a: x, b: x1}: {a: number, b: number}; ->a : Symbol(a, Decl(map.ts, 11, 24)) ->x : Symbol(x, Decl(map.ts, 11, 9)) ->b : Symbol(b, Decl(map.ts, 11, 34)) ->x1 : Symbol(x1, Decl(map.ts, 11, 14)) ->a : Symbol(a, Decl(map.ts, 11, 24)) ->b : Symbol(b, Decl(map.ts, 11, 34)) +>a : Symbol(a, Decl(map.ts, 10, 24)) +>x : Symbol(x, Decl(map.ts, 10, 9)) +>b : Symbol(b, Decl(map.ts, 10, 34)) +>x1 : Symbol(x1, Decl(map.ts, 10, 14)) +>a : Symbol(a, Decl(map.ts, 10, 24)) +>b : Symbol(b, Decl(map.ts, 10, 34)) module Z {} ->Z : Symbol(Z, Decl(map.ts, 11, 46)) +>Z : Symbol(Z, Decl(map.ts, 10, 46)) } === tests/cases/compiler/observable.ts === export declare class Observable { ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 5, 31)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 4, 31)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) filter(pred: (e:T) => boolean): Observable; >filter : Symbol(Observable.filter, Decl(observable.ts, 0, 36)) >pred : Symbol(pred, Decl(observable.ts, 1, 11)) >e : Symbol(e, Decl(observable.ts, 1, 18)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) ->Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 5, 31)) ->T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 6, 25)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) +>Observable : Symbol(Observable, Decl(observable.ts, 0, 0), Decl(map.ts, 4, 31)) +>T : Symbol(T, Decl(observable.ts, 0, 32), Decl(map.ts, 5, 25)) } === tests/cases/compiler/main.ts === @@ -68,9 +67,9 @@ let x: Observable; let y = x.map(x => x + 1); >y : Symbol(y, Decl(main.ts, 4, 3)) ->x.map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>x.map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 3, 3)) ->map : Symbol(Observable.map, Decl(map.ts, 6, 29)) +>map : Symbol(Observable.map, Decl(map.ts, 5, 29)) >x : Symbol(x, Decl(main.ts, 4, 14)) >x : Symbol(x, Decl(main.ts, 4, 14)) diff --git a/tests/baselines/reference/moduleAugmentationNoNewNames.types b/tests/baselines/reference/moduleAugmentationNoNewNames.types index 06eab66c8d148..17eadaee707c3 100644 --- a/tests/baselines/reference/moduleAugmentationNoNewNames.types +++ b/tests/baselines/reference/moduleAugmentationNoNewNames.types @@ -1,5 +1,4 @@ === tests/cases/compiler/map.ts === - import { Observable } from "./observable" >Observable : typeof Observable diff --git a/tests/baselines/reference/moduleAugmentationsBundledOutput1.js b/tests/baselines/reference/moduleAugmentationsBundledOutput1.js index 9ad2aa842d0cc..6a37e44264b32 100644 --- a/tests/baselines/reference/moduleAugmentationsBundledOutput1.js +++ b/tests/baselines/reference/moduleAugmentationsBundledOutput1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsBundledOutput1.ts] //// //// [m1.ts] - export class Cls { } diff --git a/tests/baselines/reference/moduleAugmentationsBundledOutput1.symbols b/tests/baselines/reference/moduleAugmentationsBundledOutput1.symbols index 5f98b39c2286b..b701349c5f1e4 100644 --- a/tests/baselines/reference/moduleAugmentationsBundledOutput1.symbols +++ b/tests/baselines/reference/moduleAugmentationsBundledOutput1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - export class Cls { >Cls : Symbol(Cls, Decl(m1.ts, 0, 0), Decl(m2.ts, 4, 23), Decl(m2.ts, 10, 23), Decl(m4.ts, 5, 23), Decl(m4.ts, 11, 23)) } diff --git a/tests/baselines/reference/moduleAugmentationsBundledOutput1.types b/tests/baselines/reference/moduleAugmentationsBundledOutput1.types index c3cac91fa38ad..8e0effacb44ba 100644 --- a/tests/baselines/reference/moduleAugmentationsBundledOutput1.types +++ b/tests/baselines/reference/moduleAugmentationsBundledOutput1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/m1.ts === - export class Cls { >Cls : Cls } diff --git a/tests/baselines/reference/moduleAugmentationsImports1.js b/tests/baselines/reference/moduleAugmentationsImports1.js index 116c5c5e830f3..9e40067c2fe36 100644 --- a/tests/baselines/reference/moduleAugmentationsImports1.js +++ b/tests/baselines/reference/moduleAugmentationsImports1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsImports1.ts] //// //// [a.ts] - export class A {} //// [b.ts] diff --git a/tests/baselines/reference/moduleAugmentationsImports1.symbols b/tests/baselines/reference/moduleAugmentationsImports1.symbols index 685ee9bb31c45..4a91852b8d76b 100644 --- a/tests/baselines/reference/moduleAugmentationsImports1.symbols +++ b/tests/baselines/reference/moduleAugmentationsImports1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A {} >A : Symbol(A, Decl(a.ts, 0, 0), Decl(d.ts, 9, 22), Decl(d.ts, 15, 22)) diff --git a/tests/baselines/reference/moduleAugmentationsImports1.types b/tests/baselines/reference/moduleAugmentationsImports1.types index bf0bfee0a7a6d..e708b574aaf03 100644 --- a/tests/baselines/reference/moduleAugmentationsImports1.types +++ b/tests/baselines/reference/moduleAugmentationsImports1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationsImports2.js b/tests/baselines/reference/moduleAugmentationsImports2.js index e13cbd8f3ddf9..5955cd10e59ed 100644 --- a/tests/baselines/reference/moduleAugmentationsImports2.js +++ b/tests/baselines/reference/moduleAugmentationsImports2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsImports2.ts] //// //// [a.ts] - export class A {} //// [b.ts] diff --git a/tests/baselines/reference/moduleAugmentationsImports2.symbols b/tests/baselines/reference/moduleAugmentationsImports2.symbols index 126e407da8a2d..ef023427597ca 100644 --- a/tests/baselines/reference/moduleAugmentationsImports2.symbols +++ b/tests/baselines/reference/moduleAugmentationsImports2.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A {} >A : Symbol(A, Decl(a.ts, 0, 0), Decl(d.ts, 7, 22), Decl(e.ts, 5, 22)) diff --git a/tests/baselines/reference/moduleAugmentationsImports2.types b/tests/baselines/reference/moduleAugmentationsImports2.types index 56b40625600aa..70d7e8a76001c 100644 --- a/tests/baselines/reference/moduleAugmentationsImports2.types +++ b/tests/baselines/reference/moduleAugmentationsImports2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationsImports3.js b/tests/baselines/reference/moduleAugmentationsImports3.js index a4a6ccea84955..20ff1b25271aa 100644 --- a/tests/baselines/reference/moduleAugmentationsImports3.js +++ b/tests/baselines/reference/moduleAugmentationsImports3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsImports3.ts] //// //// [a.ts] - export class A {} //// [b.ts] diff --git a/tests/baselines/reference/moduleAugmentationsImports3.symbols b/tests/baselines/reference/moduleAugmentationsImports3.symbols index fba58ffad8a97..4118ce3e9f226 100644 --- a/tests/baselines/reference/moduleAugmentationsImports3.symbols +++ b/tests/baselines/reference/moduleAugmentationsImports3.symbols @@ -31,7 +31,6 @@ let c = a.getCls().y.toLowerCase(); >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) === tests/cases/compiler/a.ts === - export class A {} >A : Symbol(A, Decl(a.ts, 0, 0), Decl(d.d.ts, 3, 16), Decl(e.ts, 6, 22)) diff --git a/tests/baselines/reference/moduleAugmentationsImports3.types b/tests/baselines/reference/moduleAugmentationsImports3.types index 04d17296c5694..030d2af80da2c 100644 --- a/tests/baselines/reference/moduleAugmentationsImports3.types +++ b/tests/baselines/reference/moduleAugmentationsImports3.types @@ -35,7 +35,6 @@ let c = a.getCls().y.toLowerCase(); >toLowerCase : () => string === tests/cases/compiler/a.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleAugmentationsImports4.js b/tests/baselines/reference/moduleAugmentationsImports4.js index 4be17a61edbc6..ee66546983d9b 100644 --- a/tests/baselines/reference/moduleAugmentationsImports4.js +++ b/tests/baselines/reference/moduleAugmentationsImports4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleAugmentationsImports4.ts] //// //// [a.ts] - export class A {} //// [b.ts] diff --git a/tests/baselines/reference/moduleAugmentationsImports4.symbols b/tests/baselines/reference/moduleAugmentationsImports4.symbols index 77b5431850eab..0c92e2c510bd2 100644 --- a/tests/baselines/reference/moduleAugmentationsImports4.symbols +++ b/tests/baselines/reference/moduleAugmentationsImports4.symbols @@ -32,7 +32,6 @@ let c = a.getCls().y.toLowerCase(); >toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) === tests/cases/compiler/a.ts === - export class A {} >A : Symbol(A, Decl(a.ts, 0, 0), Decl(d.d.ts, 3, 16), Decl(e.d.ts, 5, 16)) diff --git a/tests/baselines/reference/moduleAugmentationsImports4.types b/tests/baselines/reference/moduleAugmentationsImports4.types index 53d570e14e66f..7f4a190291f2e 100644 --- a/tests/baselines/reference/moduleAugmentationsImports4.types +++ b/tests/baselines/reference/moduleAugmentationsImports4.types @@ -36,7 +36,6 @@ let c = a.getCls().y.toLowerCase(); >toLowerCase : () => string === tests/cases/compiler/a.ts === - export class A {} >A : A diff --git a/tests/baselines/reference/moduleExportAlias.symbols b/tests/baselines/reference/moduleExportAlias.symbols index b78b6e214f367..ed480a0033c1b 100644 --- a/tests/baselines/reference/moduleExportAlias.symbols +++ b/tests/baselines/reference/moduleExportAlias.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/a.ts === - import b = require("./b.js"); >b : Symbol(b, Decl(a.ts, 0, 0)) diff --git a/tests/baselines/reference/moduleExportAlias.types b/tests/baselines/reference/moduleExportAlias.types index 9fda7560e3733..ccf8e5d7a2465 100644 --- a/tests/baselines/reference/moduleExportAlias.types +++ b/tests/baselines/reference/moduleExportAlias.types @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/a.ts === - import b = require("./b.js"); >b : typeof b diff --git a/tests/baselines/reference/moduleMergeConstructor.js b/tests/baselines/reference/moduleMergeConstructor.js index 88531532acc70..5ecaf8365d880 100644 --- a/tests/baselines/reference/moduleMergeConstructor.js +++ b/tests/baselines/reference/moduleMergeConstructor.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleMergeConstructor.ts] //// //// [foo.d.ts] - declare module "foo" { export class Foo { constructor(); diff --git a/tests/baselines/reference/moduleMergeConstructor.symbols b/tests/baselines/reference/moduleMergeConstructor.symbols index 8d9a773f144d7..bad5f3d14f4d1 100644 --- a/tests/baselines/reference/moduleMergeConstructor.symbols +++ b/tests/baselines/reference/moduleMergeConstructor.symbols @@ -1,19 +1,18 @@ === tests/cases/compiler/foo.d.ts === - declare module "foo" { export class Foo { ->Foo : Symbol(Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>Foo : Symbol(Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) constructor(); method1(): any; ->method1 : Symbol(Foo.method1, Decl(foo.d.ts, 3, 22)) +>method1 : Symbol(Foo.method1, Decl(foo.d.ts, 2, 22)) } } === tests/cases/compiler/foo-ext.d.ts === declare module "foo" { export interface Foo { ->Foo : Symbol(Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>Foo : Symbol(Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) method2(): any; >method2 : Symbol(Foo.method2, Decl(foo-ext.d.ts, 1, 26)) @@ -30,16 +29,16 @@ class Test { bar: foo.Foo; >bar : Symbol(Test.bar, Decl(index.ts, 2, 12)) >foo : Symbol(foo, Decl(index.ts, 0, 6)) ->Foo : Symbol(foo.Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>Foo : Symbol(foo.Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) constructor() { this.bar = new foo.Foo(); >this.bar : Symbol(Test.bar, Decl(index.ts, 2, 12)) >this : Symbol(Test, Decl(index.ts, 0, 27)) >bar : Symbol(Test.bar, Decl(index.ts, 2, 12)) ->foo.Foo : Symbol(foo.Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>foo.Foo : Symbol(foo.Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) >foo : Symbol(foo, Decl(index.ts, 0, 6)) ->Foo : Symbol(foo.Foo, Decl(foo.d.ts, 1, 22), Decl(foo-ext.d.ts, 0, 22)) +>Foo : Symbol(foo.Foo, Decl(foo.d.ts, 0, 22), Decl(foo-ext.d.ts, 0, 22)) } } diff --git a/tests/baselines/reference/moduleMergeConstructor.types b/tests/baselines/reference/moduleMergeConstructor.types index 48a2f01029358..5de02bba55c01 100644 --- a/tests/baselines/reference/moduleMergeConstructor.types +++ b/tests/baselines/reference/moduleMergeConstructor.types @@ -1,5 +1,4 @@ === tests/cases/compiler/foo.d.ts === - declare module "foo" { export class Foo { >Foo : Foo diff --git a/tests/baselines/reference/moduleOuterQualification.js b/tests/baselines/reference/moduleOuterQualification.js index 83c79703f99f2..c18e5d758ff73 100644 --- a/tests/baselines/reference/moduleOuterQualification.js +++ b/tests/baselines/reference/moduleOuterQualification.js @@ -1,5 +1,4 @@ //// [moduleOuterQualification.ts] - declare module outer { interface Beta { } module inner { diff --git a/tests/baselines/reference/moduleOuterQualification.symbols b/tests/baselines/reference/moduleOuterQualification.symbols index 32791347258fc..16b80668663bb 100644 --- a/tests/baselines/reference/moduleOuterQualification.symbols +++ b/tests/baselines/reference/moduleOuterQualification.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/moduleOuterQualification.ts === - declare module outer { >outer : Symbol(outer, Decl(moduleOuterQualification.ts, 0, 0)) interface Beta { } ->Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 1, 22)) +>Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 0, 22)) module inner { ->inner : Symbol(inner, Decl(moduleOuterQualification.ts, 2, 20)) +>inner : Symbol(inner, Decl(moduleOuterQualification.ts, 1, 20)) // .d.ts emit: should be 'extends outer.Beta' export interface Beta extends outer.Beta { } ->Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 3, 16)) ->outer.Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 1, 22)) +>Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 2, 16)) +>outer.Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 0, 22)) >outer : Symbol(outer, Decl(moduleOuterQualification.ts, 0, 0)) ->Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 1, 22)) +>Beta : Symbol(Beta, Decl(moduleOuterQualification.ts, 0, 22)) } } diff --git a/tests/baselines/reference/moduleOuterQualification.types b/tests/baselines/reference/moduleOuterQualification.types index 7cfab63502357..e6388b7ee7851 100644 --- a/tests/baselines/reference/moduleOuterQualification.types +++ b/tests/baselines/reference/moduleOuterQualification.types @@ -1,5 +1,4 @@ === tests/cases/compiler/moduleOuterQualification.ts === - declare module outer { >outer : any diff --git a/tests/baselines/reference/moduleResolutionNoResolve.js b/tests/baselines/reference/moduleResolutionNoResolve.js index 86f681fa27af6..d1b5315903cda 100644 --- a/tests/baselines/reference/moduleResolutionNoResolve.js +++ b/tests/baselines/reference/moduleResolutionNoResolve.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleResolutionNoResolve.ts] //// //// [a.ts] - import a = require('./b'); //// [b.ts] diff --git a/tests/baselines/reference/moduleResolutionNoResolve.symbols b/tests/baselines/reference/moduleResolutionNoResolve.symbols index 17ccfeab49680..c0fa4efda15b6 100644 --- a/tests/baselines/reference/moduleResolutionNoResolve.symbols +++ b/tests/baselines/reference/moduleResolutionNoResolve.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - import a = require('./b'); >a : Symbol(a, Decl(a.ts, 0, 0)) diff --git a/tests/baselines/reference/moduleResolutionNoResolve.types b/tests/baselines/reference/moduleResolutionNoResolve.types index dbec43bf1a210..02c61cfb6b34c 100644 --- a/tests/baselines/reference/moduleResolutionNoResolve.types +++ b/tests/baselines/reference/moduleResolutionNoResolve.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - import a = require('./b'); >a : typeof a diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.js b/tests/baselines/reference/moduleResolutionWithExtensions.js index b9a644a7209ad..c1e0310e99523 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions.js +++ b/tests/baselines/reference/moduleResolutionWithExtensions.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/externalModules/moduleResolutionWithExtensions.ts] //// //// [a.ts] - export default 0; // No extension: '.ts' added diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.symbols b/tests/baselines/reference/moduleResolutionWithExtensions.symbols index eaaa1d51cc097..5a7f9e5b62a4d 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions.symbols +++ b/tests/baselines/reference/moduleResolutionWithExtensions.symbols @@ -1,6 +1,5 @@ === /src/a.ts === - -No type information for this code.export default 0; +export default 0; No type information for this code. No type information for this code.// No extension: '.ts' added No type information for this code.=== /src/b.ts === diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.types b/tests/baselines/reference/moduleResolutionWithExtensions.types index 60196f2b25d7e..25eb5ad1fee4e 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions.types +++ b/tests/baselines/reference/moduleResolutionWithExtensions.types @@ -1,6 +1,5 @@ === /src/a.ts === - -No type information for this code.export default 0; +export default 0; No type information for this code. No type information for this code.// No extension: '.ts' added No type information for this code.=== /src/b.ts === diff --git a/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.errors.txt b/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.errors.txt index aa415a95b1b90..958837f7a0bf2 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.errors.txt +++ b/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.errors.txt @@ -16,7 +16,6 @@ ==== /tsx.tsx (0 errors) ==== - ==== /jsx.jsx (0 errors) ==== ==== /js.js (0 errors) ==== diff --git a/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.js b/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.js index 6bce8b8d3c5c9..eb6057f969303 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.js +++ b/tests/baselines/reference/moduleResolutionWithExtensions_notSupported.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleResolutionWithExtensions_notSupported.ts] //// //// [tsx.tsx] - //// [jsx.jsx] diff --git a/tests/baselines/reference/moduleResolutionWithExtensions_preferTs.js b/tests/baselines/reference/moduleResolutionWithExtensions_preferTs.js index a9dc91d9a5516..b02d23302ae76 100644 --- a/tests/baselines/reference/moduleResolutionWithExtensions_preferTs.js +++ b/tests/baselines/reference/moduleResolutionWithExtensions_preferTs.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleResolutionWithExtensions_preferTs.ts] //// //// [b.js] - //// [index.ts] export default 0; diff --git a/tests/baselines/reference/moduleResolutionWithSymlinks.js b/tests/baselines/reference/moduleResolutionWithSymlinks.js index 520324cb22239..b483f356252be 100644 --- a/tests/baselines/reference/moduleResolutionWithSymlinks.js +++ b/tests/baselines/reference/moduleResolutionWithSymlinks.js @@ -40,9 +40,9 @@ tsc app.ts # Should write to library-a/index.js, library-b/index.js, and app.js //// [/src/library-a/index.js] +"use strict"; // When symlinked files are in node_modules, they are resolved with realpath; // so a linked file does not create a duplicate SourceFile of the real one. -"use strict"; exports.__esModule = true; var MyClass = (function () { function MyClass() { diff --git a/tests/baselines/reference/moduleResolutionWithSymlinks_notInNodeModules.js b/tests/baselines/reference/moduleResolutionWithSymlinks_notInNodeModules.js index cde63e0604ded..bf51b7e3bca3e 100644 --- a/tests/baselines/reference/moduleResolutionWithSymlinks_notInNodeModules.js +++ b/tests/baselines/reference/moduleResolutionWithSymlinks_notInNodeModules.js @@ -14,17 +14,17 @@ x + x2; //// [/src/bin/shared/abc.js] +"use strict"; // When symlinked files are not in node_modules, realpath is not used. // A symlink file acts like the real thing. So, 2 symlinks act like 2 different files. // See GH#10364. -"use strict"; exports.__esModule = true; exports.x = 0; //// [/src/bin/shared2/abc.js] +"use strict"; // When symlinked files are not in node_modules, realpath is not used. // A symlink file acts like the real thing. So, 2 symlinks act like 2 different files. // See GH#10364. -"use strict"; exports.__esModule = true; exports.x = 0; //// [/src/bin/app.js] diff --git a/tests/baselines/reference/moduleResolutionWithSymlinks_withOutDir.js b/tests/baselines/reference/moduleResolutionWithSymlinks_withOutDir.js index 0bd77a1dcc78d..0049ad48f91eb 100644 --- a/tests/baselines/reference/moduleResolutionWithSymlinks_withOutDir.js +++ b/tests/baselines/reference/moduleResolutionWithSymlinks_withOutDir.js @@ -20,8 +20,8 @@ y = x; //// [/src/bin/library-a/index.js] -// Same as moduleResolutionWithSymlinks.ts, but with outDir "use strict"; +// Same as moduleResolutionWithSymlinks.ts, but with outDir exports.__esModule = true; var MyClass = (function () { function MyClass() { diff --git a/tests/baselines/reference/moduleSymbolMerging.js b/tests/baselines/reference/moduleSymbolMerging.js index d43fff1378aef..9381e47cacf35 100644 --- a/tests/baselines/reference/moduleSymbolMerging.js +++ b/tests/baselines/reference/moduleSymbolMerging.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/moduleSymbolMerging.ts] //// //// [A.ts] - module A { export interface I {} } //// [B.ts] diff --git a/tests/baselines/reference/moduleSymbolMerging.symbols b/tests/baselines/reference/moduleSymbolMerging.symbols index 4e8ca8a1526e6..010f291b9cc0b 100644 --- a/tests/baselines/reference/moduleSymbolMerging.symbols +++ b/tests/baselines/reference/moduleSymbolMerging.symbols @@ -9,13 +9,12 @@ module B { export function f(): A.I { return null; } >f : Symbol(f, Decl(B.ts, 2, 10)) >A : Symbol(A, Decl(A.ts, 0, 0), Decl(B.ts, 0, 0)) ->I : Symbol(A.I, Decl(A.ts, 1, 10)) +>I : Symbol(A.I, Decl(A.ts, 0, 10)) } === tests/cases/compiler/A.ts === - module A { export interface I {} } >A : Symbol(A, Decl(A.ts, 0, 0), Decl(B.ts, 0, 0)) ->I : Symbol(I, Decl(A.ts, 1, 10)) +>I : Symbol(I, Decl(A.ts, 0, 10)) diff --git a/tests/baselines/reference/moduleSymbolMerging.types b/tests/baselines/reference/moduleSymbolMerging.types index 0f5dfae5c3d3c..27d2a611a9fe1 100644 --- a/tests/baselines/reference/moduleSymbolMerging.types +++ b/tests/baselines/reference/moduleSymbolMerging.types @@ -15,7 +15,6 @@ module B { === tests/cases/compiler/A.ts === - module A { export interface I {} } >A : typeof A >I : I diff --git a/tests/baselines/reference/moduleVisibilityTest1.js b/tests/baselines/reference/moduleVisibilityTest1.js index 537ec23b3937c..1bae7ecfd1fc2 100644 --- a/tests/baselines/reference/moduleVisibilityTest1.js +++ b/tests/baselines/reference/moduleVisibilityTest1.js @@ -1,6 +1,4 @@ //// [moduleVisibilityTest1.ts] - - module OuterMod { export function someExportedOuterFunc() { return -1; } diff --git a/tests/baselines/reference/moduleVisibilityTest1.symbols b/tests/baselines/reference/moduleVisibilityTest1.symbols index 7c939fee5c3d2..c9c8dcd3734a6 100644 --- a/tests/baselines/reference/moduleVisibilityTest1.symbols +++ b/tests/baselines/reference/moduleVisibilityTest1.symbols @@ -1,166 +1,164 @@ === tests/cases/compiler/moduleVisibilityTest1.ts === - - module OuterMod { >OuterMod : Symbol(OuterMod, Decl(moduleVisibilityTest1.ts, 0, 0)) export function someExportedOuterFunc() { return -1; } ->someExportedOuterFunc : Symbol(someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 2, 17)) +>someExportedOuterFunc : Symbol(someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 0, 17)) export module OuterInnerMod { ->OuterInnerMod : Symbol(OuterInnerMod, Decl(moduleVisibilityTest1.ts, 3, 55)) +>OuterInnerMod : Symbol(OuterInnerMod, Decl(moduleVisibilityTest1.ts, 1, 55)) export function someExportedOuterInnerFunc() { return "foo"; } ->someExportedOuterInnerFunc : Symbol(someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 5, 30)) +>someExportedOuterInnerFunc : Symbol(someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 3, 30)) } } import OuterInnerAlias = OuterMod.OuterInnerMod; ->OuterInnerAlias : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 8, 1)) +>OuterInnerAlias : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 6, 1)) >OuterMod : Symbol(OuterMod, Decl(moduleVisibilityTest1.ts, 0, 0)) ->OuterInnerMod : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 3, 55)) +>OuterInnerMod : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 1, 55)) module M { ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) export module InnerMod { ->InnerMod : Symbol(InnerMod, Decl(moduleVisibilityTest1.ts, 12, 10)) +>InnerMod : Symbol(InnerMod, Decl(moduleVisibilityTest1.ts, 10, 10)) export function someExportedInnerFunc() { return -2; } ->someExportedInnerFunc : Symbol(someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 14, 25)) +>someExportedInnerFunc : Symbol(someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 12, 25)) } export enum E { ->E : Symbol(E, Decl(moduleVisibilityTest1.ts, 16, 2)) +>E : Symbol(E, Decl(moduleVisibilityTest1.ts, 14, 2)) A, ->A : Symbol(E.A, Decl(moduleVisibilityTest1.ts, 18, 16)) +>A : Symbol(E.A, Decl(moduleVisibilityTest1.ts, 16, 16)) B, ->B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 19, 4)) +>B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 17, 4)) C, ->C : Symbol(E.C, Decl(moduleVisibilityTest1.ts, 20, 4)) +>C : Symbol(E.C, Decl(moduleVisibilityTest1.ts, 18, 4)) } export var x = 5; ->x : Symbol(x, Decl(moduleVisibilityTest1.ts, 24, 11)) +>x : Symbol(x, Decl(moduleVisibilityTest1.ts, 22, 11)) export declare var exported_var; ->exported_var : Symbol(exported_var, Decl(moduleVisibilityTest1.ts, 25, 19)) +>exported_var : Symbol(exported_var, Decl(moduleVisibilityTest1.ts, 23, 19)) var y = x + x; ->y : Symbol(y, Decl(moduleVisibilityTest1.ts, 27, 4)) ->x : Symbol(x, Decl(moduleVisibilityTest1.ts, 24, 11)) ->x : Symbol(x, Decl(moduleVisibilityTest1.ts, 24, 11)) +>y : Symbol(y, Decl(moduleVisibilityTest1.ts, 25, 4)) +>x : Symbol(x, Decl(moduleVisibilityTest1.ts, 22, 11)) +>x : Symbol(x, Decl(moduleVisibilityTest1.ts, 22, 11)) export interface I { ->I : Symbol(I, Decl(moduleVisibilityTest1.ts, 27, 15)) +>I : Symbol(I, Decl(moduleVisibilityTest1.ts, 25, 15)) someMethod():number; ->someMethod : Symbol(I.someMethod, Decl(moduleVisibilityTest1.ts, 30, 21)) +>someMethod : Symbol(I.someMethod, Decl(moduleVisibilityTest1.ts, 28, 21)) } class B {public b = 0;} ->B : Symbol(B, Decl(moduleVisibilityTest1.ts, 32, 2)) ->b : Symbol(B.b, Decl(moduleVisibilityTest1.ts, 34, 11)) +>B : Symbol(B, Decl(moduleVisibilityTest1.ts, 30, 2)) +>b : Symbol(B.b, Decl(moduleVisibilityTest1.ts, 32, 11)) export class C implements I { ->C : Symbol(C, Decl(moduleVisibilityTest1.ts, 34, 25)) ->I : Symbol(I, Decl(moduleVisibilityTest1.ts, 27, 15)) +>C : Symbol(C, Decl(moduleVisibilityTest1.ts, 32, 25)) +>I : Symbol(I, Decl(moduleVisibilityTest1.ts, 25, 15)) public someMethodThatCallsAnOuterMethod() {return OuterInnerAlias.someExportedOuterInnerFunc();} ->someMethodThatCallsAnOuterMethod : Symbol(C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 36, 31)) ->OuterInnerAlias.someExportedOuterInnerFunc : Symbol(OuterInnerAlias.someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 5, 30)) ->OuterInnerAlias : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 8, 1)) ->someExportedOuterInnerFunc : Symbol(OuterInnerAlias.someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 5, 30)) +>someMethodThatCallsAnOuterMethod : Symbol(C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 34, 31)) +>OuterInnerAlias.someExportedOuterInnerFunc : Symbol(OuterInnerAlias.someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 3, 30)) +>OuterInnerAlias : Symbol(OuterInnerAlias, Decl(moduleVisibilityTest1.ts, 6, 1)) +>someExportedOuterInnerFunc : Symbol(OuterInnerAlias.someExportedOuterInnerFunc, Decl(moduleVisibilityTest1.ts, 3, 30)) public someMethodThatCallsAnInnerMethod() {return InnerMod.someExportedInnerFunc();} ->someMethodThatCallsAnInnerMethod : Symbol(C.someMethodThatCallsAnInnerMethod, Decl(moduleVisibilityTest1.ts, 37, 98)) ->InnerMod.someExportedInnerFunc : Symbol(InnerMod.someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 14, 25)) ->InnerMod : Symbol(InnerMod, Decl(moduleVisibilityTest1.ts, 12, 10)) ->someExportedInnerFunc : Symbol(InnerMod.someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 14, 25)) +>someMethodThatCallsAnInnerMethod : Symbol(C.someMethodThatCallsAnInnerMethod, Decl(moduleVisibilityTest1.ts, 35, 98)) +>InnerMod.someExportedInnerFunc : Symbol(InnerMod.someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 12, 25)) +>InnerMod : Symbol(InnerMod, Decl(moduleVisibilityTest1.ts, 10, 10)) +>someExportedInnerFunc : Symbol(InnerMod.someExportedInnerFunc, Decl(moduleVisibilityTest1.ts, 12, 25)) public someMethodThatCallsAnOuterInnerMethod() {return OuterMod.someExportedOuterFunc();} ->someMethodThatCallsAnOuterInnerMethod : Symbol(C.someMethodThatCallsAnOuterInnerMethod, Decl(moduleVisibilityTest1.ts, 38, 86)) ->OuterMod.someExportedOuterFunc : Symbol(OuterMod.someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 2, 17)) +>someMethodThatCallsAnOuterInnerMethod : Symbol(C.someMethodThatCallsAnOuterInnerMethod, Decl(moduleVisibilityTest1.ts, 36, 86)) +>OuterMod.someExportedOuterFunc : Symbol(OuterMod.someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 0, 17)) >OuterMod : Symbol(OuterMod, Decl(moduleVisibilityTest1.ts, 0, 0)) ->someExportedOuterFunc : Symbol(OuterMod.someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 2, 17)) +>someExportedOuterFunc : Symbol(OuterMod.someExportedOuterFunc, Decl(moduleVisibilityTest1.ts, 0, 17)) public someMethod() { return 0; } ->someMethod : Symbol(C.someMethod, Decl(moduleVisibilityTest1.ts, 39, 91)) +>someMethod : Symbol(C.someMethod, Decl(moduleVisibilityTest1.ts, 37, 91)) public someProp = 1; ->someProp : Symbol(C.someProp, Decl(moduleVisibilityTest1.ts, 40, 35)) +>someProp : Symbol(C.someProp, Decl(moduleVisibilityTest1.ts, 38, 35)) constructor() { function someInnerFunc() { return 2; } ->someInnerFunc : Symbol(someInnerFunc, Decl(moduleVisibilityTest1.ts, 43, 17)) +>someInnerFunc : Symbol(someInnerFunc, Decl(moduleVisibilityTest1.ts, 41, 17)) var someInnerVar = 3; ->someInnerVar : Symbol(someInnerVar, Decl(moduleVisibilityTest1.ts, 45, 15)) +>someInnerVar : Symbol(someInnerVar, Decl(moduleVisibilityTest1.ts, 43, 15)) } } var someModuleVar = 4; ->someModuleVar : Symbol(someModuleVar, Decl(moduleVisibilityTest1.ts, 49, 4)) +>someModuleVar : Symbol(someModuleVar, Decl(moduleVisibilityTest1.ts, 47, 4)) function someModuleFunction() { return 5;} ->someModuleFunction : Symbol(someModuleFunction, Decl(moduleVisibilityTest1.ts, 49, 23)) +>someModuleFunction : Symbol(someModuleFunction, Decl(moduleVisibilityTest1.ts, 47, 23)) } module M { ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) export var c = x; ->c : Symbol(c, Decl(moduleVisibilityTest1.ts, 55, 11)) ->x : Symbol(x, Decl(moduleVisibilityTest1.ts, 24, 11)) +>c : Symbol(c, Decl(moduleVisibilityTest1.ts, 53, 11)) +>x : Symbol(x, Decl(moduleVisibilityTest1.ts, 22, 11)) export var meb = M.E.B; ->meb : Symbol(meb, Decl(moduleVisibilityTest1.ts, 56, 11)) ->M.E.B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 19, 4)) ->M.E : Symbol(E, Decl(moduleVisibilityTest1.ts, 16, 2)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->E : Symbol(E, Decl(moduleVisibilityTest1.ts, 16, 2)) ->B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 19, 4)) +>meb : Symbol(meb, Decl(moduleVisibilityTest1.ts, 54, 11)) +>M.E.B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 17, 4)) +>M.E : Symbol(E, Decl(moduleVisibilityTest1.ts, 14, 2)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>E : Symbol(E, Decl(moduleVisibilityTest1.ts, 14, 2)) +>B : Symbol(E.B, Decl(moduleVisibilityTest1.ts, 17, 4)) } var cprime : M.I = null; ->cprime : Symbol(cprime, Decl(moduleVisibilityTest1.ts, 59, 3)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->I : Symbol(M.I, Decl(moduleVisibilityTest1.ts, 27, 15)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->I : Symbol(M.I, Decl(moduleVisibilityTest1.ts, 27, 15)) +>cprime : Symbol(cprime, Decl(moduleVisibilityTest1.ts, 57, 3)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>I : Symbol(M.I, Decl(moduleVisibilityTest1.ts, 25, 15)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>I : Symbol(M.I, Decl(moduleVisibilityTest1.ts, 25, 15)) var c = new M.C(); ->c : Symbol(c, Decl(moduleVisibilityTest1.ts, 61, 3)) ->M.C : Symbol(M.C, Decl(moduleVisibilityTest1.ts, 34, 25)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->C : Symbol(M.C, Decl(moduleVisibilityTest1.ts, 34, 25)) +>c : Symbol(c, Decl(moduleVisibilityTest1.ts, 59, 3)) +>M.C : Symbol(M.C, Decl(moduleVisibilityTest1.ts, 32, 25)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>C : Symbol(M.C, Decl(moduleVisibilityTest1.ts, 32, 25)) var z = M.x; ->z : Symbol(z, Decl(moduleVisibilityTest1.ts, 62, 3)) ->M.x : Symbol(M.x, Decl(moduleVisibilityTest1.ts, 24, 11)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->x : Symbol(M.x, Decl(moduleVisibilityTest1.ts, 24, 11)) +>z : Symbol(z, Decl(moduleVisibilityTest1.ts, 60, 3)) +>M.x : Symbol(M.x, Decl(moduleVisibilityTest1.ts, 22, 11)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>x : Symbol(M.x, Decl(moduleVisibilityTest1.ts, 22, 11)) var alpha = M.E.A; ->alpha : Symbol(alpha, Decl(moduleVisibilityTest1.ts, 63, 3)) ->M.E.A : Symbol(M.E.A, Decl(moduleVisibilityTest1.ts, 18, 16)) ->M.E : Symbol(M.E, Decl(moduleVisibilityTest1.ts, 16, 2)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->E : Symbol(M.E, Decl(moduleVisibilityTest1.ts, 16, 2)) ->A : Symbol(M.E.A, Decl(moduleVisibilityTest1.ts, 18, 16)) +>alpha : Symbol(alpha, Decl(moduleVisibilityTest1.ts, 61, 3)) +>M.E.A : Symbol(M.E.A, Decl(moduleVisibilityTest1.ts, 16, 16)) +>M.E : Symbol(M.E, Decl(moduleVisibilityTest1.ts, 14, 2)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>E : Symbol(M.E, Decl(moduleVisibilityTest1.ts, 14, 2)) +>A : Symbol(M.E.A, Decl(moduleVisibilityTest1.ts, 16, 16)) var omega = M.exported_var; ->omega : Symbol(omega, Decl(moduleVisibilityTest1.ts, 64, 3)) ->M.exported_var : Symbol(M.exported_var, Decl(moduleVisibilityTest1.ts, 25, 19)) ->M : Symbol(M, Decl(moduleVisibilityTest1.ts, 10, 48), Decl(moduleVisibilityTest1.ts, 52, 1)) ->exported_var : Symbol(M.exported_var, Decl(moduleVisibilityTest1.ts, 25, 19)) +>omega : Symbol(omega, Decl(moduleVisibilityTest1.ts, 62, 3)) +>M.exported_var : Symbol(M.exported_var, Decl(moduleVisibilityTest1.ts, 23, 19)) +>M : Symbol(M, Decl(moduleVisibilityTest1.ts, 8, 48), Decl(moduleVisibilityTest1.ts, 50, 1)) +>exported_var : Symbol(M.exported_var, Decl(moduleVisibilityTest1.ts, 23, 19)) c.someMethodThatCallsAnOuterMethod(); ->c.someMethodThatCallsAnOuterMethod : Symbol(M.C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 36, 31)) ->c : Symbol(c, Decl(moduleVisibilityTest1.ts, 61, 3)) ->someMethodThatCallsAnOuterMethod : Symbol(M.C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 36, 31)) +>c.someMethodThatCallsAnOuterMethod : Symbol(M.C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 34, 31)) +>c : Symbol(c, Decl(moduleVisibilityTest1.ts, 59, 3)) +>someMethodThatCallsAnOuterMethod : Symbol(M.C.someMethodThatCallsAnOuterMethod, Decl(moduleVisibilityTest1.ts, 34, 31)) diff --git a/tests/baselines/reference/moduleVisibilityTest1.types b/tests/baselines/reference/moduleVisibilityTest1.types index c8b7a1a8e3187..e2171eb6e59ce 100644 --- a/tests/baselines/reference/moduleVisibilityTest1.types +++ b/tests/baselines/reference/moduleVisibilityTest1.types @@ -1,6 +1,4 @@ === tests/cases/compiler/moduleVisibilityTest1.ts === - - module OuterMod { >OuterMod : typeof OuterMod diff --git a/tests/baselines/reference/moduleVisibilityTest2.errors.txt b/tests/baselines/reference/moduleVisibilityTest2.errors.txt index d7b991f9f6291..2b5686124b835 100644 --- a/tests/baselines/reference/moduleVisibilityTest2.errors.txt +++ b/tests/baselines/reference/moduleVisibilityTest2.errors.txt @@ -1,14 +1,12 @@ -tests/cases/compiler/moduleVisibilityTest2.ts(57,17): error TS2304: Cannot find name 'x'. -tests/cases/compiler/moduleVisibilityTest2.ts(58,21): error TS2339: Property 'E' does not exist on type 'typeof M'. -tests/cases/compiler/moduleVisibilityTest2.ts(61,16): error TS2694: Namespace 'M' has no exported member 'I'. -tests/cases/compiler/moduleVisibilityTest2.ts(61,23): error TS2694: Namespace 'M' has no exported member 'I'. -tests/cases/compiler/moduleVisibilityTest2.ts(64,11): error TS2339: Property 'x' does not exist on type 'typeof M'. -tests/cases/compiler/moduleVisibilityTest2.ts(65,15): error TS2339: Property 'E' does not exist on type 'typeof M'. +tests/cases/compiler/moduleVisibilityTest2.ts(55,17): error TS2304: Cannot find name 'x'. +tests/cases/compiler/moduleVisibilityTest2.ts(56,21): error TS2339: Property 'E' does not exist on type 'typeof M'. +tests/cases/compiler/moduleVisibilityTest2.ts(59,16): error TS2694: Namespace 'M' has no exported member 'I'. +tests/cases/compiler/moduleVisibilityTest2.ts(59,23): error TS2694: Namespace 'M' has no exported member 'I'. +tests/cases/compiler/moduleVisibilityTest2.ts(62,11): error TS2339: Property 'x' does not exist on type 'typeof M'. +tests/cases/compiler/moduleVisibilityTest2.ts(63,15): error TS2339: Property 'E' does not exist on type 'typeof M'. ==== tests/cases/compiler/moduleVisibilityTest2.ts (6 errors) ==== - - module OuterMod { export function someExportedOuterFunc() { return -1; } diff --git a/tests/baselines/reference/moduleVisibilityTest2.js b/tests/baselines/reference/moduleVisibilityTest2.js index 62b12b8780846..b40d1721b6531 100644 --- a/tests/baselines/reference/moduleVisibilityTest2.js +++ b/tests/baselines/reference/moduleVisibilityTest2.js @@ -1,6 +1,4 @@ //// [moduleVisibilityTest2.ts] - - module OuterMod { export function someExportedOuterFunc() { return -1; } diff --git a/tests/baselines/reference/moduledecl.js b/tests/baselines/reference/moduledecl.js index 437907017fcda..b2dd3caaf3512 100644 --- a/tests/baselines/reference/moduledecl.js +++ b/tests/baselines/reference/moduledecl.js @@ -1,5 +1,4 @@ //// [moduledecl.ts] - module a { } diff --git a/tests/baselines/reference/moduledecl.symbols b/tests/baselines/reference/moduledecl.symbols index f0b2db9121caa..2fd96aee32194 100644 --- a/tests/baselines/reference/moduledecl.symbols +++ b/tests/baselines/reference/moduledecl.symbols @@ -1,271 +1,270 @@ === tests/cases/compiler/moduledecl.ts === - module a { >a : Symbol(a, Decl(moduledecl.ts, 0, 0)) } module b.a { ->b : Symbol(b, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(a, Decl(moduledecl.ts, 4, 9)) +>b : Symbol(b, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(a, Decl(moduledecl.ts, 3, 9)) } module c.a.b { ->c : Symbol(c, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(a, Decl(moduledecl.ts, 7, 9)) ->b : Symbol(ma.b, Decl(moduledecl.ts, 7, 11)) +>c : Symbol(c, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(a, Decl(moduledecl.ts, 6, 9)) +>b : Symbol(ma.b, Decl(moduledecl.ts, 6, 11)) import ma = a; ->ma : Symbol(ma, Decl(moduledecl.ts, 7, 14)) ->a : Symbol(ma, Decl(moduledecl.ts, 7, 9)) +>ma : Symbol(ma, Decl(moduledecl.ts, 6, 14)) +>a : Symbol(ma, Decl(moduledecl.ts, 6, 9)) } module mImport { ->mImport : Symbol(mImport, Decl(moduledecl.ts, 9, 1)) +>mImport : Symbol(mImport, Decl(moduledecl.ts, 8, 1)) import d = a; ->d : Symbol(d, Decl(moduledecl.ts, 11, 16)) +>d : Symbol(d, Decl(moduledecl.ts, 10, 16)) >a : Symbol(d, Decl(moduledecl.ts, 0, 0)) import e = b.a; ->e : Symbol(e, Decl(moduledecl.ts, 12, 17)) ->b : Symbol(b, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(e, Decl(moduledecl.ts, 4, 9)) +>e : Symbol(e, Decl(moduledecl.ts, 11, 17)) +>b : Symbol(b, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(e, Decl(moduledecl.ts, 3, 9)) import d1 = a; ->d1 : Symbol(d1, Decl(moduledecl.ts, 13, 19)) +>d1 : Symbol(d1, Decl(moduledecl.ts, 12, 19)) >a : Symbol(d, Decl(moduledecl.ts, 0, 0)) import e1 = b.a; ->e1 : Symbol(e1, Decl(moduledecl.ts, 14, 18)) ->b : Symbol(b, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(e, Decl(moduledecl.ts, 4, 9)) +>e1 : Symbol(e1, Decl(moduledecl.ts, 13, 18)) +>b : Symbol(b, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(e, Decl(moduledecl.ts, 3, 9)) } module m0 { ->m0 : Symbol(m0, Decl(moduledecl.ts, 16, 1)) +>m0 : Symbol(m0, Decl(moduledecl.ts, 15, 1)) function f1() { ->f1 : Symbol(f1, Decl(moduledecl.ts, 18, 11)) +>f1 : Symbol(f1, Decl(moduledecl.ts, 17, 11)) } function f2(s: string); ->f2 : Symbol(f2, Decl(moduledecl.ts, 20, 5), Decl(moduledecl.ts, 22, 27), Decl(moduledecl.ts, 23, 27)) ->s : Symbol(s, Decl(moduledecl.ts, 22, 16)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 19, 5), Decl(moduledecl.ts, 21, 27), Decl(moduledecl.ts, 22, 27)) +>s : Symbol(s, Decl(moduledecl.ts, 21, 16)) function f2(n: number); ->f2 : Symbol(f2, Decl(moduledecl.ts, 20, 5), Decl(moduledecl.ts, 22, 27), Decl(moduledecl.ts, 23, 27)) ->n : Symbol(n, Decl(moduledecl.ts, 23, 16)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 19, 5), Decl(moduledecl.ts, 21, 27), Decl(moduledecl.ts, 22, 27)) +>n : Symbol(n, Decl(moduledecl.ts, 22, 16)) function f2(ns: any) { ->f2 : Symbol(f2, Decl(moduledecl.ts, 20, 5), Decl(moduledecl.ts, 22, 27), Decl(moduledecl.ts, 23, 27)) ->ns : Symbol(ns, Decl(moduledecl.ts, 24, 16)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 19, 5), Decl(moduledecl.ts, 21, 27), Decl(moduledecl.ts, 22, 27)) +>ns : Symbol(ns, Decl(moduledecl.ts, 23, 16)) } class c1 { ->c1 : Symbol(c1, Decl(moduledecl.ts, 25, 5)) +>c1 : Symbol(c1, Decl(moduledecl.ts, 24, 5)) public a : ()=>string; ->a : Symbol(c1.a, Decl(moduledecl.ts, 27, 14)) +>a : Symbol(c1.a, Decl(moduledecl.ts, 26, 14)) private b: ()=>number; ->b : Symbol(c1.b, Decl(moduledecl.ts, 28, 30)) +>b : Symbol(c1.b, Decl(moduledecl.ts, 27, 30)) private static s1; ->s1 : Symbol(c1.s1, Decl(moduledecl.ts, 29, 30)) +>s1 : Symbol(c1.s1, Decl(moduledecl.ts, 28, 30)) public static s2; ->s2 : Symbol(c1.s2, Decl(moduledecl.ts, 30, 26)) +>s2 : Symbol(c1.s2, Decl(moduledecl.ts, 29, 26)) } interface i1 { ->i1 : Symbol(i1, Decl(moduledecl.ts, 32, 5)) +>i1 : Symbol(i1, Decl(moduledecl.ts, 31, 5)) () : Object; >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [n: number]: c1; ->n : Symbol(n, Decl(moduledecl.ts, 36, 9)) ->c1 : Symbol(c1, Decl(moduledecl.ts, 25, 5)) +>n : Symbol(n, Decl(moduledecl.ts, 35, 9)) +>c1 : Symbol(c1, Decl(moduledecl.ts, 24, 5)) } import m2 = a; ->m2 : Symbol(m2, Decl(moduledecl.ts, 37, 5)) +>m2 : Symbol(m2, Decl(moduledecl.ts, 36, 5)) >a : Symbol(m2, Decl(moduledecl.ts, 0, 0)) import m3 = b; ->m3 : Symbol(m3, Decl(moduledecl.ts, 39, 18)) ->b : Symbol(m3, Decl(moduledecl.ts, 2, 1)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 38, 18)) +>b : Symbol(m3, Decl(moduledecl.ts, 1, 1)) import m4 = b.a; ->m4 : Symbol(m4, Decl(moduledecl.ts, 40, 18)) ->b : Symbol(m3, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(m3.a, Decl(moduledecl.ts, 4, 9)) +>m4 : Symbol(m4, Decl(moduledecl.ts, 39, 18)) +>b : Symbol(m3, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(m3.a, Decl(moduledecl.ts, 3, 9)) import m5 = c; ->m5 : Symbol(m5, Decl(moduledecl.ts, 41, 20)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) +>m5 : Symbol(m5, Decl(moduledecl.ts, 40, 20)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) import m6 = c.a; ->m6 : Symbol(m6, Decl(moduledecl.ts, 42, 18)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(m5.a, Decl(moduledecl.ts, 7, 9)) +>m6 : Symbol(m6, Decl(moduledecl.ts, 41, 18)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(m5.a, Decl(moduledecl.ts, 6, 9)) import m7 = c.a.b; ->m7 : Symbol(m7, Decl(moduledecl.ts, 43, 20)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(m5.a, Decl(moduledecl.ts, 7, 9)) ->b : Symbol(m6.b, Decl(moduledecl.ts, 7, 11)) +>m7 : Symbol(m7, Decl(moduledecl.ts, 42, 20)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(m5.a, Decl(moduledecl.ts, 6, 9)) +>b : Symbol(m6.b, Decl(moduledecl.ts, 6, 11)) } module m1 { ->m1 : Symbol(m1, Decl(moduledecl.ts, 45, 1)) +>m1 : Symbol(m1, Decl(moduledecl.ts, 44, 1)) export function f1() { ->f1 : Symbol(f1, Decl(moduledecl.ts, 47, 11)) +>f1 : Symbol(f1, Decl(moduledecl.ts, 46, 11)) } export function f2(s: string); ->f2 : Symbol(f2, Decl(moduledecl.ts, 49, 5), Decl(moduledecl.ts, 51, 34), Decl(moduledecl.ts, 52, 34)) ->s : Symbol(s, Decl(moduledecl.ts, 51, 23)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 48, 5), Decl(moduledecl.ts, 50, 34), Decl(moduledecl.ts, 51, 34)) +>s : Symbol(s, Decl(moduledecl.ts, 50, 23)) export function f2(n: number); ->f2 : Symbol(f2, Decl(moduledecl.ts, 49, 5), Decl(moduledecl.ts, 51, 34), Decl(moduledecl.ts, 52, 34)) ->n : Symbol(n, Decl(moduledecl.ts, 52, 23)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 48, 5), Decl(moduledecl.ts, 50, 34), Decl(moduledecl.ts, 51, 34)) +>n : Symbol(n, Decl(moduledecl.ts, 51, 23)) export function f2(ns: any) { ->f2 : Symbol(f2, Decl(moduledecl.ts, 49, 5), Decl(moduledecl.ts, 51, 34), Decl(moduledecl.ts, 52, 34)) ->ns : Symbol(ns, Decl(moduledecl.ts, 53, 23)) +>f2 : Symbol(f2, Decl(moduledecl.ts, 48, 5), Decl(moduledecl.ts, 50, 34), Decl(moduledecl.ts, 51, 34)) +>ns : Symbol(ns, Decl(moduledecl.ts, 52, 23)) } export class c1 { ->c1 : Symbol(c1, Decl(moduledecl.ts, 54, 5)) +>c1 : Symbol(c1, Decl(moduledecl.ts, 53, 5)) public a: () =>string; ->a : Symbol(c1.a, Decl(moduledecl.ts, 56, 21)) +>a : Symbol(c1.a, Decl(moduledecl.ts, 55, 21)) private b: () =>number; ->b : Symbol(c1.b, Decl(moduledecl.ts, 57, 30)) +>b : Symbol(c1.b, Decl(moduledecl.ts, 56, 30)) private static s1; ->s1 : Symbol(c1.s1, Decl(moduledecl.ts, 58, 31)) +>s1 : Symbol(c1.s1, Decl(moduledecl.ts, 57, 31)) public static s2; ->s2 : Symbol(c1.s2, Decl(moduledecl.ts, 59, 26)) +>s2 : Symbol(c1.s2, Decl(moduledecl.ts, 58, 26)) public d() { ->d : Symbol(c1.d, Decl(moduledecl.ts, 60, 25)) +>d : Symbol(c1.d, Decl(moduledecl.ts, 59, 25)) return "Hello"; } public e: { x: number; y: string; }; ->e : Symbol(c1.e, Decl(moduledecl.ts, 64, 9)) ->x : Symbol(x, Decl(moduledecl.ts, 66, 19)) ->y : Symbol(y, Decl(moduledecl.ts, 66, 30)) +>e : Symbol(c1.e, Decl(moduledecl.ts, 63, 9)) +>x : Symbol(x, Decl(moduledecl.ts, 65, 19)) +>y : Symbol(y, Decl(moduledecl.ts, 65, 30)) constructor (public n, public n2: number, private n3, private n4: string) { ->n : Symbol(c1.n, Decl(moduledecl.ts, 67, 21)) ->n2 : Symbol(c1.n2, Decl(moduledecl.ts, 67, 30)) ->n3 : Symbol(c1.n3, Decl(moduledecl.ts, 67, 49)) ->n4 : Symbol(c1.n4, Decl(moduledecl.ts, 67, 61)) +>n : Symbol(c1.n, Decl(moduledecl.ts, 66, 21)) +>n2 : Symbol(c1.n2, Decl(moduledecl.ts, 66, 30)) +>n3 : Symbol(c1.n3, Decl(moduledecl.ts, 66, 49)) +>n4 : Symbol(c1.n4, Decl(moduledecl.ts, 66, 61)) } } export interface i1 { ->i1 : Symbol(i1, Decl(moduledecl.ts, 69, 5)) +>i1 : Symbol(i1, Decl(moduledecl.ts, 68, 5)) () : Object; >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [n: number]: c1; ->n : Symbol(n, Decl(moduledecl.ts, 73, 9)) ->c1 : Symbol(c1, Decl(moduledecl.ts, 54, 5)) +>n : Symbol(n, Decl(moduledecl.ts, 72, 9)) +>c1 : Symbol(c1, Decl(moduledecl.ts, 53, 5)) } import m2 = a; ->m2 : Symbol(m2, Decl(moduledecl.ts, 74, 5)) +>m2 : Symbol(m2, Decl(moduledecl.ts, 73, 5)) >a : Symbol(m2, Decl(moduledecl.ts, 0, 0)) import m3 = b; ->m3 : Symbol(m3, Decl(moduledecl.ts, 76, 18)) ->b : Symbol(m3, Decl(moduledecl.ts, 2, 1)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 75, 18)) +>b : Symbol(m3, Decl(moduledecl.ts, 1, 1)) import m4 = b.a; ->m4 : Symbol(m4, Decl(moduledecl.ts, 77, 18)) ->b : Symbol(m3, Decl(moduledecl.ts, 2, 1)) ->a : Symbol(m3.a, Decl(moduledecl.ts, 4, 9)) +>m4 : Symbol(m4, Decl(moduledecl.ts, 76, 18)) +>b : Symbol(m3, Decl(moduledecl.ts, 1, 1)) +>a : Symbol(m3.a, Decl(moduledecl.ts, 3, 9)) import m5 = c; ->m5 : Symbol(m5, Decl(moduledecl.ts, 78, 20)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) +>m5 : Symbol(m5, Decl(moduledecl.ts, 77, 20)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) import m6 = c.a; ->m6 : Symbol(m6, Decl(moduledecl.ts, 79, 18)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(m5.a, Decl(moduledecl.ts, 7, 9)) +>m6 : Symbol(m6, Decl(moduledecl.ts, 78, 18)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(m5.a, Decl(moduledecl.ts, 6, 9)) import m7 = c.a.b; ->m7 : Symbol(m7, Decl(moduledecl.ts, 80, 20)) ->c : Symbol(m5, Decl(moduledecl.ts, 5, 1)) ->a : Symbol(m5.a, Decl(moduledecl.ts, 7, 9)) ->b : Symbol(m6.b, Decl(moduledecl.ts, 7, 11)) +>m7 : Symbol(m7, Decl(moduledecl.ts, 79, 20)) +>c : Symbol(m5, Decl(moduledecl.ts, 4, 1)) +>a : Symbol(m5.a, Decl(moduledecl.ts, 6, 9)) +>b : Symbol(m6.b, Decl(moduledecl.ts, 6, 11)) } module m { ->m : Symbol(m, Decl(moduledecl.ts, 82, 1), Decl(moduledecl.ts, 93, 1)) +>m : Symbol(m, Decl(moduledecl.ts, 81, 1), Decl(moduledecl.ts, 92, 1)) export module m2 { ->m2 : Symbol(m2, Decl(moduledecl.ts, 84, 10)) +>m2 : Symbol(m2, Decl(moduledecl.ts, 83, 10)) var a = 10; ->a : Symbol(a, Decl(moduledecl.ts, 86, 11)) +>a : Symbol(a, Decl(moduledecl.ts, 85, 11)) export var b: number; ->b : Symbol(b, Decl(moduledecl.ts, 87, 18)) +>b : Symbol(b, Decl(moduledecl.ts, 86, 18)) } export module m3 { ->m3 : Symbol(m3, Decl(moduledecl.ts, 88, 5)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 87, 5)) export var c: number; ->c : Symbol(c, Decl(moduledecl.ts, 91, 18)) +>c : Symbol(c, Decl(moduledecl.ts, 90, 18)) } } module m { ->m : Symbol(m, Decl(moduledecl.ts, 82, 1), Decl(moduledecl.ts, 93, 1)) +>m : Symbol(m, Decl(moduledecl.ts, 81, 1), Decl(moduledecl.ts, 92, 1)) export module m25 { ->m25 : Symbol(m25, Decl(moduledecl.ts, 95, 10)) +>m25 : Symbol(m25, Decl(moduledecl.ts, 94, 10)) export module m5 { ->m5 : Symbol(m5, Decl(moduledecl.ts, 97, 23)) +>m5 : Symbol(m5, Decl(moduledecl.ts, 96, 23)) export var c: number; ->c : Symbol(c, Decl(moduledecl.ts, 99, 22)) +>c : Symbol(c, Decl(moduledecl.ts, 98, 22)) } } } module m13 { ->m13 : Symbol(m13, Decl(moduledecl.ts, 102, 1)) +>m13 : Symbol(m13, Decl(moduledecl.ts, 101, 1)) export module m4 { ->m4 : Symbol(m4, Decl(moduledecl.ts, 104, 12)) +>m4 : Symbol(m4, Decl(moduledecl.ts, 103, 12)) export module m2 { ->m2 : Symbol(m2, Decl(moduledecl.ts, 105, 22)) +>m2 : Symbol(m2, Decl(moduledecl.ts, 104, 22)) export module m3 { ->m3 : Symbol(m3, Decl(moduledecl.ts, 106, 26)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 105, 26)) export var c: number; ->c : Symbol(c, Decl(moduledecl.ts, 108, 26)) +>c : Symbol(c, Decl(moduledecl.ts, 107, 26)) } } export function f() { ->f : Symbol(f, Decl(moduledecl.ts, 110, 9)) +>f : Symbol(f, Decl(moduledecl.ts, 109, 9)) return 20; } @@ -273,264 +272,264 @@ module m13 { } declare module m4 { ->m4 : Symbol(m4, Decl(moduledecl.ts, 116, 1)) +>m4 : Symbol(m4, Decl(moduledecl.ts, 115, 1)) export var b; ->b : Symbol(b, Decl(moduledecl.ts, 119, 14)) +>b : Symbol(b, Decl(moduledecl.ts, 118, 14)) } declare module m5 { ->m5 : Symbol(m5, Decl(moduledecl.ts, 120, 1)) +>m5 : Symbol(m5, Decl(moduledecl.ts, 119, 1)) export var c; ->c : Symbol(c, Decl(moduledecl.ts, 123, 14)) +>c : Symbol(c, Decl(moduledecl.ts, 122, 14)) } declare module m43 { ->m43 : Symbol(m43, Decl(moduledecl.ts, 124, 1)) +>m43 : Symbol(m43, Decl(moduledecl.ts, 123, 1)) export var b; ->b : Symbol(b, Decl(moduledecl.ts, 127, 14)) +>b : Symbol(b, Decl(moduledecl.ts, 126, 14)) } declare module m55 { ->m55 : Symbol(m55, Decl(moduledecl.ts, 128, 1)) +>m55 : Symbol(m55, Decl(moduledecl.ts, 127, 1)) export var c; ->c : Symbol(c, Decl(moduledecl.ts, 131, 14)) +>c : Symbol(c, Decl(moduledecl.ts, 130, 14)) } declare module "m3" { export var b: number; ->b : Symbol(b, Decl(moduledecl.ts, 135, 14)) +>b : Symbol(b, Decl(moduledecl.ts, 134, 14)) } module exportTests { ->exportTests : Symbol(exportTests, Decl(moduledecl.ts, 136, 1)) +>exportTests : Symbol(exportTests, Decl(moduledecl.ts, 135, 1)) export class C1_public { ->C1_public : Symbol(C1_public, Decl(moduledecl.ts, 138, 20)) +>C1_public : Symbol(C1_public, Decl(moduledecl.ts, 137, 20)) private f2() { ->f2 : Symbol(C1_public.f2, Decl(moduledecl.ts, 139, 28)) +>f2 : Symbol(C1_public.f2, Decl(moduledecl.ts, 138, 28)) return 30; } public f3() { ->f3 : Symbol(C1_public.f3, Decl(moduledecl.ts, 142, 9)) +>f3 : Symbol(C1_public.f3, Decl(moduledecl.ts, 141, 9)) return "string"; } } class C2_private { ->C2_private : Symbol(C2_private, Decl(moduledecl.ts, 147, 5)) +>C2_private : Symbol(C2_private, Decl(moduledecl.ts, 146, 5)) private f2() { ->f2 : Symbol(C2_private.f2, Decl(moduledecl.ts, 148, 22)) +>f2 : Symbol(C2_private.f2, Decl(moduledecl.ts, 147, 22)) return 30; } public f3() { ->f3 : Symbol(C2_private.f3, Decl(moduledecl.ts, 151, 9)) +>f3 : Symbol(C2_private.f3, Decl(moduledecl.ts, 150, 9)) return "string"; } } export class C3_public { ->C3_public : Symbol(C3_public, Decl(moduledecl.ts, 156, 5)) +>C3_public : Symbol(C3_public, Decl(moduledecl.ts, 155, 5)) private getC2_private() { ->getC2_private : Symbol(C3_public.getC2_private, Decl(moduledecl.ts, 158, 28)) +>getC2_private : Symbol(C3_public.getC2_private, Decl(moduledecl.ts, 157, 28)) return new C2_private(); ->C2_private : Symbol(C2_private, Decl(moduledecl.ts, 147, 5)) +>C2_private : Symbol(C2_private, Decl(moduledecl.ts, 146, 5)) } private setC2_private(arg: C2_private) { ->setC2_private : Symbol(C3_public.setC2_private, Decl(moduledecl.ts, 161, 9)) ->arg : Symbol(arg, Decl(moduledecl.ts, 162, 30)) ->C2_private : Symbol(C2_private, Decl(moduledecl.ts, 147, 5)) +>setC2_private : Symbol(C3_public.setC2_private, Decl(moduledecl.ts, 160, 9)) +>arg : Symbol(arg, Decl(moduledecl.ts, 161, 30)) +>C2_private : Symbol(C2_private, Decl(moduledecl.ts, 146, 5)) } private get c2() { ->c2 : Symbol(C3_public.c2, Decl(moduledecl.ts, 163, 9)) +>c2 : Symbol(C3_public.c2, Decl(moduledecl.ts, 162, 9)) return new C2_private(); ->C2_private : Symbol(C2_private, Decl(moduledecl.ts, 147, 5)) +>C2_private : Symbol(C2_private, Decl(moduledecl.ts, 146, 5)) } public getC1_public() { ->getC1_public : Symbol(C3_public.getC1_public, Decl(moduledecl.ts, 166, 9)) +>getC1_public : Symbol(C3_public.getC1_public, Decl(moduledecl.ts, 165, 9)) return new C1_public(); ->C1_public : Symbol(C1_public, Decl(moduledecl.ts, 138, 20)) +>C1_public : Symbol(C1_public, Decl(moduledecl.ts, 137, 20)) } public setC1_public(arg: C1_public) { ->setC1_public : Symbol(C3_public.setC1_public, Decl(moduledecl.ts, 169, 9)) ->arg : Symbol(arg, Decl(moduledecl.ts, 170, 28)) ->C1_public : Symbol(C1_public, Decl(moduledecl.ts, 138, 20)) +>setC1_public : Symbol(C3_public.setC1_public, Decl(moduledecl.ts, 168, 9)) +>arg : Symbol(arg, Decl(moduledecl.ts, 169, 28)) +>C1_public : Symbol(C1_public, Decl(moduledecl.ts, 137, 20)) } public get c1() { ->c1 : Symbol(C3_public.c1, Decl(moduledecl.ts, 171, 9)) +>c1 : Symbol(C3_public.c1, Decl(moduledecl.ts, 170, 9)) return new C1_public(); ->C1_public : Symbol(C1_public, Decl(moduledecl.ts, 138, 20)) +>C1_public : Symbol(C1_public, Decl(moduledecl.ts, 137, 20)) } } } declare module mAmbient { ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) class C { ->C : Symbol(C, Decl(moduledecl.ts, 178, 25)) +>C : Symbol(C, Decl(moduledecl.ts, 177, 25)) public myProp: number; ->myProp : Symbol(C.myProp, Decl(moduledecl.ts, 179, 13)) +>myProp : Symbol(C.myProp, Decl(moduledecl.ts, 178, 13)) } function foo() : C; ->foo : Symbol(foo, Decl(moduledecl.ts, 181, 5)) ->C : Symbol(C, Decl(moduledecl.ts, 178, 25)) +>foo : Symbol(foo, Decl(moduledecl.ts, 180, 5)) +>C : Symbol(C, Decl(moduledecl.ts, 177, 25)) var aVar: C; ->aVar : Symbol(aVar, Decl(moduledecl.ts, 184, 7)) ->C : Symbol(C, Decl(moduledecl.ts, 178, 25)) +>aVar : Symbol(aVar, Decl(moduledecl.ts, 183, 7)) +>C : Symbol(C, Decl(moduledecl.ts, 177, 25)) interface B { ->B : Symbol(B, Decl(moduledecl.ts, 184, 16)) +>B : Symbol(B, Decl(moduledecl.ts, 183, 16)) x: number; ->x : Symbol(B.x, Decl(moduledecl.ts, 185, 17)) +>x : Symbol(B.x, Decl(moduledecl.ts, 184, 17)) y: C; ->y : Symbol(B.y, Decl(moduledecl.ts, 186, 18)) ->C : Symbol(C, Decl(moduledecl.ts, 178, 25)) +>y : Symbol(B.y, Decl(moduledecl.ts, 185, 18)) +>C : Symbol(C, Decl(moduledecl.ts, 177, 25)) } enum e { ->e : Symbol(e, Decl(moduledecl.ts, 188, 5)) +>e : Symbol(e, Decl(moduledecl.ts, 187, 5)) x, ->x : Symbol(e.x, Decl(moduledecl.ts, 189, 12)) +>x : Symbol(e.x, Decl(moduledecl.ts, 188, 12)) y, ->y : Symbol(e.y, Decl(moduledecl.ts, 190, 10)) +>y : Symbol(e.y, Decl(moduledecl.ts, 189, 10)) z ->z : Symbol(e.z, Decl(moduledecl.ts, 191, 10)) +>z : Symbol(e.z, Decl(moduledecl.ts, 190, 10)) } module m3 { ->m3 : Symbol(m3, Decl(moduledecl.ts, 193, 5)) +>m3 : Symbol(m3, Decl(moduledecl.ts, 192, 5)) class C { ->C : Symbol(C, Decl(moduledecl.ts, 195, 15)) +>C : Symbol(C, Decl(moduledecl.ts, 194, 15)) public myProp: number; ->myProp : Symbol(C.myProp, Decl(moduledecl.ts, 196, 17)) +>myProp : Symbol(C.myProp, Decl(moduledecl.ts, 195, 17)) } function foo(): C; ->foo : Symbol(foo, Decl(moduledecl.ts, 198, 9)) ->C : Symbol(C, Decl(moduledecl.ts, 195, 15)) +>foo : Symbol(foo, Decl(moduledecl.ts, 197, 9)) +>C : Symbol(C, Decl(moduledecl.ts, 194, 15)) var aVar: C; ->aVar : Symbol(aVar, Decl(moduledecl.ts, 201, 11)) ->C : Symbol(C, Decl(moduledecl.ts, 195, 15)) +>aVar : Symbol(aVar, Decl(moduledecl.ts, 200, 11)) +>C : Symbol(C, Decl(moduledecl.ts, 194, 15)) interface B { ->B : Symbol(B, Decl(moduledecl.ts, 201, 20)) +>B : Symbol(B, Decl(moduledecl.ts, 200, 20)) x: number; ->x : Symbol(B.x, Decl(moduledecl.ts, 202, 21)) +>x : Symbol(B.x, Decl(moduledecl.ts, 201, 21)) y: C; ->y : Symbol(B.y, Decl(moduledecl.ts, 203, 22)) ->C : Symbol(C, Decl(moduledecl.ts, 195, 15)) +>y : Symbol(B.y, Decl(moduledecl.ts, 202, 22)) +>C : Symbol(C, Decl(moduledecl.ts, 194, 15)) } enum e { ->e : Symbol(e, Decl(moduledecl.ts, 205, 9)) +>e : Symbol(e, Decl(moduledecl.ts, 204, 9)) x, ->x : Symbol(e.x, Decl(moduledecl.ts, 206, 16)) +>x : Symbol(e.x, Decl(moduledecl.ts, 205, 16)) y, ->y : Symbol(e.y, Decl(moduledecl.ts, 207, 14)) +>y : Symbol(e.y, Decl(moduledecl.ts, 206, 14)) z ->z : Symbol(e.z, Decl(moduledecl.ts, 208, 14)) +>z : Symbol(e.z, Decl(moduledecl.ts, 207, 14)) } } } function foo() { ->foo : Symbol(foo, Decl(moduledecl.ts, 212, 1)) +>foo : Symbol(foo, Decl(moduledecl.ts, 211, 1)) return mAmbient.foo(); ->mAmbient.foo : Symbol(mAmbient.foo, Decl(moduledecl.ts, 181, 5)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->foo : Symbol(mAmbient.foo, Decl(moduledecl.ts, 181, 5)) +>mAmbient.foo : Symbol(mAmbient.foo, Decl(moduledecl.ts, 180, 5)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>foo : Symbol(mAmbient.foo, Decl(moduledecl.ts, 180, 5)) } var cVar = new mAmbient.C(); ->cVar : Symbol(cVar, Decl(moduledecl.ts, 218, 3)) ->mAmbient.C : Symbol(mAmbient.C, Decl(moduledecl.ts, 178, 25)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->C : Symbol(mAmbient.C, Decl(moduledecl.ts, 178, 25)) +>cVar : Symbol(cVar, Decl(moduledecl.ts, 217, 3)) +>mAmbient.C : Symbol(mAmbient.C, Decl(moduledecl.ts, 177, 25)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>C : Symbol(mAmbient.C, Decl(moduledecl.ts, 177, 25)) var aVar = mAmbient.aVar; ->aVar : Symbol(aVar, Decl(moduledecl.ts, 219, 3)) ->mAmbient.aVar : Symbol(mAmbient.aVar, Decl(moduledecl.ts, 184, 7)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->aVar : Symbol(mAmbient.aVar, Decl(moduledecl.ts, 184, 7)) +>aVar : Symbol(aVar, Decl(moduledecl.ts, 218, 3)) +>mAmbient.aVar : Symbol(mAmbient.aVar, Decl(moduledecl.ts, 183, 7)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>aVar : Symbol(mAmbient.aVar, Decl(moduledecl.ts, 183, 7)) var bB: mAmbient.B; ->bB : Symbol(bB, Decl(moduledecl.ts, 220, 3)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->B : Symbol(mAmbient.B, Decl(moduledecl.ts, 184, 16)) +>bB : Symbol(bB, Decl(moduledecl.ts, 219, 3)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>B : Symbol(mAmbient.B, Decl(moduledecl.ts, 183, 16)) var eVar: mAmbient.e; ->eVar : Symbol(eVar, Decl(moduledecl.ts, 221, 3)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->e : Symbol(mAmbient.e, Decl(moduledecl.ts, 188, 5)) +>eVar : Symbol(eVar, Decl(moduledecl.ts, 220, 3)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>e : Symbol(mAmbient.e, Decl(moduledecl.ts, 187, 5)) function m3foo() { ->m3foo : Symbol(m3foo, Decl(moduledecl.ts, 221, 21)) +>m3foo : Symbol(m3foo, Decl(moduledecl.ts, 220, 21)) return mAmbient.m3.foo(); ->mAmbient.m3.foo : Symbol(mAmbient.m3.foo, Decl(moduledecl.ts, 198, 9)) ->mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->foo : Symbol(mAmbient.m3.foo, Decl(moduledecl.ts, 198, 9)) +>mAmbient.m3.foo : Symbol(mAmbient.m3.foo, Decl(moduledecl.ts, 197, 9)) +>mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>foo : Symbol(mAmbient.m3.foo, Decl(moduledecl.ts, 197, 9)) } var m3cVar = new mAmbient.m3.C(); ->m3cVar : Symbol(m3cVar, Decl(moduledecl.ts, 227, 3)) ->mAmbient.m3.C : Symbol(mAmbient.m3.C, Decl(moduledecl.ts, 195, 15)) ->mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->C : Symbol(mAmbient.m3.C, Decl(moduledecl.ts, 195, 15)) +>m3cVar : Symbol(m3cVar, Decl(moduledecl.ts, 226, 3)) +>mAmbient.m3.C : Symbol(mAmbient.m3.C, Decl(moduledecl.ts, 194, 15)) +>mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>C : Symbol(mAmbient.m3.C, Decl(moduledecl.ts, 194, 15)) var m3aVar = mAmbient.m3.aVar; ->m3aVar : Symbol(m3aVar, Decl(moduledecl.ts, 228, 3)) ->mAmbient.m3.aVar : Symbol(mAmbient.m3.aVar, Decl(moduledecl.ts, 201, 11)) ->mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->aVar : Symbol(mAmbient.m3.aVar, Decl(moduledecl.ts, 201, 11)) +>m3aVar : Symbol(m3aVar, Decl(moduledecl.ts, 227, 3)) +>mAmbient.m3.aVar : Symbol(mAmbient.m3.aVar, Decl(moduledecl.ts, 200, 11)) +>mAmbient.m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>aVar : Symbol(mAmbient.m3.aVar, Decl(moduledecl.ts, 200, 11)) var m3bB: mAmbient.m3.B; ->m3bB : Symbol(m3bB, Decl(moduledecl.ts, 229, 3)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->B : Symbol(mAmbient.m3.B, Decl(moduledecl.ts, 201, 20)) +>m3bB : Symbol(m3bB, Decl(moduledecl.ts, 228, 3)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>B : Symbol(mAmbient.m3.B, Decl(moduledecl.ts, 200, 20)) var m3eVar: mAmbient.m3.e; ->m3eVar : Symbol(m3eVar, Decl(moduledecl.ts, 230, 3)) ->mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 176, 1)) ->m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 193, 5)) ->e : Symbol(mAmbient.m3.e, Decl(moduledecl.ts, 205, 9)) +>m3eVar : Symbol(m3eVar, Decl(moduledecl.ts, 229, 3)) +>mAmbient : Symbol(mAmbient, Decl(moduledecl.ts, 175, 1)) +>m3 : Symbol(mAmbient.m3, Decl(moduledecl.ts, 192, 5)) +>e : Symbol(mAmbient.m3.e, Decl(moduledecl.ts, 204, 9)) diff --git a/tests/baselines/reference/moduledecl.types b/tests/baselines/reference/moduledecl.types index e638286197228..4dfd012356fa2 100644 --- a/tests/baselines/reference/moduledecl.types +++ b/tests/baselines/reference/moduledecl.types @@ -1,5 +1,4 @@ === tests/cases/compiler/moduledecl.ts === - module a { >a : any } diff --git a/tests/baselines/reference/multipleDefaultExports01.errors.txt b/tests/baselines/reference/multipleDefaultExports01.errors.txt index 16aa3b2f7b15b..b53d4113dedcd 100644 --- a/tests/baselines/reference/multipleDefaultExports01.errors.txt +++ b/tests/baselines/reference/multipleDefaultExports01.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2528: A module cannot have multiple default exports. -tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2528: A module cannot have multiple default exports. -tests/cases/conformance/es6/modules/m1.ts(11,1): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/m1.ts(1,22): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/m1.ts(5,25): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/m1.ts(10,1): error TS2528: A module cannot have multiple default exports. tests/cases/conformance/es6/modules/m2.ts(3,1): error TS2348: Value of type 'typeof foo' is not callable. Did you mean to include 'new'? ==== tests/cases/conformance/es6/modules/m1.ts (3 errors) ==== - export default class foo { ~~~ !!! error TS2528: A module cannot have multiple default exports. diff --git a/tests/baselines/reference/multipleDefaultExports01.js b/tests/baselines/reference/multipleDefaultExports01.js index 98c170518094d..06e53505451c7 100644 --- a/tests/baselines/reference/multipleDefaultExports01.js +++ b/tests/baselines/reference/multipleDefaultExports01.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/multipleDefaultExports01.ts] //// //// [m1.ts] - export default class foo { } diff --git a/tests/baselines/reference/multipleDefaultExports02.errors.txt b/tests/baselines/reference/multipleDefaultExports02.errors.txt index 3f27db47c9434..97a36e064557d 100644 --- a/tests/baselines/reference/multipleDefaultExports02.errors.txt +++ b/tests/baselines/reference/multipleDefaultExports02.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/modules/m1.ts(2,25): error TS2323: Cannot redeclare exported variable 'default'. -tests/cases/conformance/es6/modules/m1.ts(2,25): error TS2393: Duplicate function implementation. -tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2323: Cannot redeclare exported variable 'default'. -tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/modules/m1.ts(1,25): error TS2323: Cannot redeclare exported variable 'default'. +tests/cases/conformance/es6/modules/m1.ts(1,25): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/modules/m1.ts(5,25): error TS2323: Cannot redeclare exported variable 'default'. +tests/cases/conformance/es6/modules/m1.ts(5,25): error TS2393: Duplicate function implementation. ==== tests/cases/conformance/es6/modules/m1.ts (4 errors) ==== - export default function foo() { ~~~ !!! error TS2323: Cannot redeclare exported variable 'default'. diff --git a/tests/baselines/reference/multipleDefaultExports02.js b/tests/baselines/reference/multipleDefaultExports02.js index b129dba039232..e2827120da2e6 100644 --- a/tests/baselines/reference/multipleDefaultExports02.js +++ b/tests/baselines/reference/multipleDefaultExports02.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/multipleDefaultExports02.ts] //// //// [m1.ts] - export default function foo() { } diff --git a/tests/baselines/reference/multipleDefaultExports03.errors.txt b/tests/baselines/reference/multipleDefaultExports03.errors.txt index 5c4b075b009bd..5b4fc84070ba3 100644 --- a/tests/baselines/reference/multipleDefaultExports03.errors.txt +++ b/tests/baselines/reference/multipleDefaultExports03.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(2,22): error TS2528: A module cannot have multiple default exports. -tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(5,22): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(1,22): error TS2528: A module cannot have multiple default exports. +tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(4,22): error TS2528: A module cannot have multiple default exports. ==== tests/cases/conformance/es6/modules/multipleDefaultExports03.ts (2 errors) ==== - export default class C { ~ !!! error TS2528: A module cannot have multiple default exports. diff --git a/tests/baselines/reference/multipleDefaultExports03.js b/tests/baselines/reference/multipleDefaultExports03.js index 897a3f00eb443..3b02dd523d7c0 100644 --- a/tests/baselines/reference/multipleDefaultExports03.js +++ b/tests/baselines/reference/multipleDefaultExports03.js @@ -1,5 +1,4 @@ //// [multipleDefaultExports03.ts] - export default class C { } diff --git a/tests/baselines/reference/multipleDefaultExports04.errors.txt b/tests/baselines/reference/multipleDefaultExports04.errors.txt index bf137e3cc1758..2b40316252df3 100644 --- a/tests/baselines/reference/multipleDefaultExports04.errors.txt +++ b/tests/baselines/reference/multipleDefaultExports04.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(2,25): error TS2323: Cannot redeclare exported variable 'default'. -tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(2,25): error TS2393: Duplicate function implementation. -tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(5,25): error TS2323: Cannot redeclare exported variable 'default'. -tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(5,25): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(1,25): error TS2323: Cannot redeclare exported variable 'default'. +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(1,25): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(4,25): error TS2323: Cannot redeclare exported variable 'default'. +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(4,25): error TS2393: Duplicate function implementation. ==== tests/cases/conformance/es6/modules/multipleDefaultExports04.ts (4 errors) ==== - export default function f() { ~ !!! error TS2323: Cannot redeclare exported variable 'default'. diff --git a/tests/baselines/reference/multipleDefaultExports04.js b/tests/baselines/reference/multipleDefaultExports04.js index 341f6f41c629e..b488bae33ef52 100644 --- a/tests/baselines/reference/multipleDefaultExports04.js +++ b/tests/baselines/reference/multipleDefaultExports04.js @@ -1,5 +1,4 @@ //// [multipleDefaultExports04.ts] - export default function f() { } diff --git a/tests/baselines/reference/multipleExports.errors.txt b/tests/baselines/reference/multipleExports.errors.txt index 43e9c4bffa317..df422fb9d6ffb 100644 --- a/tests/baselines/reference/multipleExports.errors.txt +++ b/tests/baselines/reference/multipleExports.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/multipleExports.ts(10,5): error TS1194: Export declarations are not permitted in a namespace. -tests/cases/compiler/multipleExports.ts(10,13): error TS2484: Export declaration conflicts with exported declaration of 'x'. +tests/cases/compiler/multipleExports.ts(9,5): error TS1194: Export declarations are not permitted in a namespace. +tests/cases/compiler/multipleExports.ts(9,13): error TS2484: Export declaration conflicts with exported declaration of 'x'. ==== tests/cases/compiler/multipleExports.ts (2 errors) ==== - export module M { export var v = 0; export let x; diff --git a/tests/baselines/reference/multipleExports.js b/tests/baselines/reference/multipleExports.js index 052765914474b..284b24ef4f9e0 100644 --- a/tests/baselines/reference/multipleExports.js +++ b/tests/baselines/reference/multipleExports.js @@ -1,5 +1,4 @@ //// [multipleExports.ts] - export module M { export var v = 0; export let x; diff --git a/tests/baselines/reference/namespacesDeclaration1.js b/tests/baselines/reference/namespacesDeclaration1.js index b722dc1fc0003..d9ecbf163693e 100644 --- a/tests/baselines/reference/namespacesDeclaration1.js +++ b/tests/baselines/reference/namespacesDeclaration1.js @@ -1,5 +1,4 @@ //// [namespacesDeclaration1.ts] - module M { export namespace N { export module M2 { diff --git a/tests/baselines/reference/namespacesDeclaration1.symbols b/tests/baselines/reference/namespacesDeclaration1.symbols index 512bc9757aa79..1589bf446964a 100644 --- a/tests/baselines/reference/namespacesDeclaration1.symbols +++ b/tests/baselines/reference/namespacesDeclaration1.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/namespacesDeclaration1.ts === - module M { >M : Symbol(M, Decl(namespacesDeclaration1.ts, 0, 0)) export namespace N { ->N : Symbol(N, Decl(namespacesDeclaration1.ts, 1, 10)) +>N : Symbol(N, Decl(namespacesDeclaration1.ts, 0, 10)) export module M2 { ->M2 : Symbol(M2, Decl(namespacesDeclaration1.ts, 2, 23)) +>M2 : Symbol(M2, Decl(namespacesDeclaration1.ts, 1, 23)) export interface I {} ->I : Symbol(I, Decl(namespacesDeclaration1.ts, 3, 24)) +>I : Symbol(I, Decl(namespacesDeclaration1.ts, 2, 24)) } } } diff --git a/tests/baselines/reference/namespacesDeclaration1.types b/tests/baselines/reference/namespacesDeclaration1.types index e99f5d0e6c39b..1b671f1870653 100644 --- a/tests/baselines/reference/namespacesDeclaration1.types +++ b/tests/baselines/reference/namespacesDeclaration1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/namespacesDeclaration1.ts === - module M { >M : any diff --git a/tests/baselines/reference/namespacesDeclaration2.errors.txt b/tests/baselines/reference/namespacesDeclaration2.errors.txt index 50c64b7d83abb..1f6ff170be74c 100644 --- a/tests/baselines/reference/namespacesDeclaration2.errors.txt +++ b/tests/baselines/reference/namespacesDeclaration2.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/namespacesDeclaration2.ts(13,13): error TS2694: Namespace 'N' has no exported member 'S'. -tests/cases/compiler/namespacesDeclaration2.ts(14,12): error TS2694: Namespace 'M' has no exported member 'F'. -tests/cases/compiler/namespacesDeclaration2.ts(15,11): error TS2694: Namespace 'ns' has no exported member 'A'. +tests/cases/compiler/namespacesDeclaration2.ts(12,13): error TS2694: Namespace 'N' has no exported member 'S'. +tests/cases/compiler/namespacesDeclaration2.ts(13,12): error TS2694: Namespace 'M' has no exported member 'F'. +tests/cases/compiler/namespacesDeclaration2.ts(14,11): error TS2694: Namespace 'ns' has no exported member 'A'. ==== tests/cases/compiler/namespacesDeclaration2.ts (3 errors) ==== - namespace N { function S() {} } diff --git a/tests/baselines/reference/namespacesDeclaration2.js b/tests/baselines/reference/namespacesDeclaration2.js index d680e781145ad..7c74da322d826 100644 --- a/tests/baselines/reference/namespacesDeclaration2.js +++ b/tests/baselines/reference/namespacesDeclaration2.js @@ -1,5 +1,4 @@ //// [namespacesDeclaration2.ts] - namespace N { function S() {} } diff --git a/tests/baselines/reference/narrowedConstInMethod.js b/tests/baselines/reference/narrowedConstInMethod.js index f4cdc3def9184..e2bd1c1cd21b7 100644 --- a/tests/baselines/reference/narrowedConstInMethod.js +++ b/tests/baselines/reference/narrowedConstInMethod.js @@ -1,5 +1,4 @@ //// [narrowedConstInMethod.ts] - function f() { const x: string | null = {}; if (x !== null) { diff --git a/tests/baselines/reference/narrowedConstInMethod.symbols b/tests/baselines/reference/narrowedConstInMethod.symbols index 1fd05dcea5ead..f16837bf1bd93 100644 --- a/tests/baselines/reference/narrowedConstInMethod.symbols +++ b/tests/baselines/reference/narrowedConstInMethod.symbols @@ -1,19 +1,18 @@ === tests/cases/compiler/narrowedConstInMethod.ts === - function f() { >f : Symbol(f, Decl(narrowedConstInMethod.ts, 0, 0)) const x: string | null = {}; ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9)) if (x !== null) { ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9)) return { bar() { return x.length; } // Error: possibly null x ->bar : Symbol(bar, Decl(narrowedConstInMethod.ts, 4, 16)) +>bar : Symbol(bar, Decl(narrowedConstInMethod.ts, 3, 16)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) }; @@ -21,19 +20,19 @@ function f() { } function f2() { ->f2 : Symbol(f2, Decl(narrowedConstInMethod.ts, 8, 1)) +>f2 : Symbol(f2, Decl(narrowedConstInMethod.ts, 7, 1)) const x: string | null = {}; ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9)) if (x !== null) { ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9)) return class { bar() { return x.length; } // Error: possibly null x ->bar : Symbol((Anonymous class).bar, Decl(narrowedConstInMethod.ts, 13, 22)) +>bar : Symbol((Anonymous class).bar, Decl(narrowedConstInMethod.ts, 12, 22)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) }; diff --git a/tests/baselines/reference/narrowedConstInMethod.types b/tests/baselines/reference/narrowedConstInMethod.types index a73f2edfccbea..1f3886cc5883b 100644 --- a/tests/baselines/reference/narrowedConstInMethod.types +++ b/tests/baselines/reference/narrowedConstInMethod.types @@ -1,5 +1,4 @@ === tests/cases/compiler/narrowedConstInMethod.ts === - function f() { >f : () => { bar(): number; } | undefined diff --git a/tests/baselines/reference/narrowingByDiscriminantInLoop.js b/tests/baselines/reference/narrowingByDiscriminantInLoop.js index 88cc87772dda4..a5eea76cfd58a 100644 --- a/tests/baselines/reference/narrowingByDiscriminantInLoop.js +++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.js @@ -1,5 +1,4 @@ //// [narrowingByDiscriminantInLoop.ts] - // Repro from #9977 type IDLMemberTypes = OperationMemberType | ConstantMemberType; diff --git a/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols b/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols index edb0f1958c22d..572a775293d92 100644 --- a/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols +++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols @@ -1,238 +1,237 @@ === tests/cases/compiler/narrowingByDiscriminantInLoop.ts === - // Repro from #9977 type IDLMemberTypes = OperationMemberType | ConstantMemberType; >IDLMemberTypes : Symbol(IDLMemberTypes, Decl(narrowingByDiscriminantInLoop.ts, 0, 0)) ->OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 11, 1)) ->ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 16, 1)) +>OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 10, 1)) +>ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 15, 1)) interface IDLTypeDescription { ->IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 3, 63)) +>IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 2, 63)) origin: string; ->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) +>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) } interface InterfaceType { ->InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 7, 1)) +>InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 6, 1)) members: IDLMemberTypes[]; ->members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) +>members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) >IDLMemberTypes : Symbol(IDLMemberTypes, Decl(narrowingByDiscriminantInLoop.ts, 0, 0)) } interface OperationMemberType { ->OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 11, 1)) +>OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 10, 1)) type: "operation"; ->type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) +>type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) idlType: IDLTypeDescription; ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 3, 63)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 2, 63)) } interface ConstantMemberType { ->ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 16, 1)) +>ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 15, 1)) type: "const"; ->type : Symbol(ConstantMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) +>type : Symbol(ConstantMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) idlType: string; ->idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) +>idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) } function insertInterface(callbackType: InterfaceType) { ->insertInterface : Symbol(insertInterface, Decl(narrowingByDiscriminantInLoop.ts, 21, 1)) ->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 23, 25)) ->InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 7, 1)) +>insertInterface : Symbol(insertInterface, Decl(narrowingByDiscriminantInLoop.ts, 20, 1)) +>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 22, 25)) +>InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 6, 1)) for (const memberType of callbackType.members) { ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) ->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 23, 25)) ->members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) +>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 22, 25)) +>members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) if (memberType.type === "const") { ->memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) +>memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) memberType.idlType; // string ->memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) +>memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) } else if (memberType.type === "operation") { ->memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) +>memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) memberType.idlType.origin; // string ->memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) ->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) +>memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) +>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) (memberType.idlType as IDLTypeDescription); ->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14)) ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 3, 63)) +>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 2, 63)) } } } function insertInterface2(callbackType: InterfaceType) { ->insertInterface2 : Symbol(insertInterface2, Decl(narrowingByDiscriminantInLoop.ts, 33, 1)) ->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 35, 26)) ->InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 7, 1)) +>insertInterface2 : Symbol(insertInterface2, Decl(narrowingByDiscriminantInLoop.ts, 32, 1)) +>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 34, 26)) +>InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 6, 1)) for (const memberType of callbackType.members) { ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 36, 14)) ->callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) ->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 35, 26)) ->members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 35, 14)) +>callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) +>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 34, 26)) +>members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25)) if (memberType.type === "operation") { ->memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 36, 14)) ->type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) +>memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 35, 14)) +>type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) memberType.idlType.origin; // string ->memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) ->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 36, 14)) ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) +>memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) +>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 35, 14)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) } } } function foo(memberType: IDLMemberTypes) { ->foo : Symbol(foo, Decl(narrowingByDiscriminantInLoop.ts, 41, 1)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) +>foo : Symbol(foo, Decl(narrowingByDiscriminantInLoop.ts, 40, 1)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) >IDLMemberTypes : Symbol(IDLMemberTypes, Decl(narrowingByDiscriminantInLoop.ts, 0, 0)) if (memberType.type === "const") { ->memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) ->type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30)) +>memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) +>type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30)) memberType.idlType; // string ->memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) ->idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18)) +>memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) +>idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18)) } else if (memberType.type === "operation") { ->memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) ->type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31)) +>memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) +>type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31)) memberType.idlType.origin; // string ->memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) ->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13)) ->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22)) ->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30)) +>memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) +>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13)) +>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22)) +>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30)) } } // Repro for issue similar to #8383 interface A { ->A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 50, 1)) +>A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 49, 1)) kind: true; ->kind : Symbol(A.kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13)) +>kind : Symbol(A.kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13)) prop: { a: string; }; ->prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) +>prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) } interface B { ->B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 57, 1)) +>B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 56, 1)) kind: false; ->kind : Symbol(B.kind, Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>kind : Symbol(B.kind, Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) prop: { b: string; } ->prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) +>prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) } function f1(x: A | B) { ->f1 : Symbol(f1, Decl(narrowingByDiscriminantInLoop.ts, 62, 1)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 50, 1)) ->B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 57, 1)) +>f1 : Symbol(f1, Decl(narrowingByDiscriminantInLoop.ts, 61, 1)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 49, 1)) +>B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 56, 1)) while (true) { x.prop; ->x.prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15), Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15), Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) +>x.prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15), Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15), Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) if (x.kind === true) { ->x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) x.prop.a; ->x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) ->x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) +>x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) +>x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) } if (x.kind === false) { ->x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) x.prop.b; ->x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) ->x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12)) ->prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) +>x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) +>x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 63, 12)) +>prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) } } } function f2(x: A | B) { ->f2 : Symbol(f2, Decl(narrowingByDiscriminantInLoop.ts, 74, 1)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 50, 1)) ->B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 57, 1)) +>f2 : Symbol(f2, Decl(narrowingByDiscriminantInLoop.ts, 73, 1)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 49, 1)) +>B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 56, 1)) while (true) { if (x.kind) { ->x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) x.prop.a; ->x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) ->x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15)) ->a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11)) +>x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) +>x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 54, 15)) +>a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 55, 11)) } if (!x.kind) { ->x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13)) +>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 53, 13), Decl(narrowingByDiscriminantInLoop.ts, 58, 13)) x.prop.b; ->x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) ->x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12)) ->prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16)) ->b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11)) +>x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) +>x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 75, 12)) +>prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 59, 16)) +>b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 60, 11)) } } } diff --git a/tests/baselines/reference/narrowingByDiscriminantInLoop.types b/tests/baselines/reference/narrowingByDiscriminantInLoop.types index c0f6fe73bcaa0..7c4ab046f4ee5 100644 --- a/tests/baselines/reference/narrowingByDiscriminantInLoop.types +++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.types @@ -1,5 +1,4 @@ === tests/cases/compiler/narrowingByDiscriminantInLoop.ts === - // Repro from #9977 type IDLMemberTypes = OperationMemberType | ConstantMemberType; diff --git a/tests/baselines/reference/narrowingConstrainedTypeParameter.js b/tests/baselines/reference/narrowingConstrainedTypeParameter.js index 4663e706d1b43..a29468388516a 100644 --- a/tests/baselines/reference/narrowingConstrainedTypeParameter.js +++ b/tests/baselines/reference/narrowingConstrainedTypeParameter.js @@ -1,5 +1,4 @@ //// [narrowingConstrainedTypeParameter.ts] - // Repro from #10811 interface Pet { @@ -18,8 +17,8 @@ export function speak(pet: TPet, voice: (pet: TPet) => string) } //// [narrowingConstrainedTypeParameter.js] -// Repro from #10811 "use strict"; +// Repro from #10811 exports.__esModule = true; function isPet(pet) { return typeof pet.name === "string"; diff --git a/tests/baselines/reference/narrowingConstrainedTypeParameter.symbols b/tests/baselines/reference/narrowingConstrainedTypeParameter.symbols index 89ca39e98a28c..0510f1b594550 100644 --- a/tests/baselines/reference/narrowingConstrainedTypeParameter.symbols +++ b/tests/baselines/reference/narrowingConstrainedTypeParameter.symbols @@ -1,42 +1,41 @@ === tests/cases/compiler/narrowingConstrainedTypeParameter.ts === - // Repro from #10811 interface Pet { >Pet : Symbol(Pet, Decl(narrowingConstrainedTypeParameter.ts, 0, 0)) name: string; ->name : Symbol(Pet.name, Decl(narrowingConstrainedTypeParameter.ts, 3, 15)) +>name : Symbol(Pet.name, Decl(narrowingConstrainedTypeParameter.ts, 2, 15)) } function isPet(pet: any): pet is Pet { ->isPet : Symbol(isPet, Decl(narrowingConstrainedTypeParameter.ts, 5, 1)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 7, 15)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 7, 15)) +>isPet : Symbol(isPet, Decl(narrowingConstrainedTypeParameter.ts, 4, 1)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 6, 15)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 6, 15)) >Pet : Symbol(Pet, Decl(narrowingConstrainedTypeParameter.ts, 0, 0)) return typeof pet.name === "string"; ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 7, 15)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 6, 15)) } export function speak(pet: TPet, voice: (pet: TPet) => string): string { ->speak : Symbol(speak, Decl(narrowingConstrainedTypeParameter.ts, 9, 1)) ->TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 11, 22)) +>speak : Symbol(speak, Decl(narrowingConstrainedTypeParameter.ts, 8, 1)) +>TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 10, 22)) >Pet : Symbol(Pet, Decl(narrowingConstrainedTypeParameter.ts, 0, 0)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 11, 40)) ->TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 11, 22)) ->voice : Symbol(voice, Decl(narrowingConstrainedTypeParameter.ts, 11, 50)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 11, 59)) ->TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 11, 22)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 10, 40)) +>TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 10, 22)) +>voice : Symbol(voice, Decl(narrowingConstrainedTypeParameter.ts, 10, 50)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 10, 59)) +>TPet : Symbol(TPet, Decl(narrowingConstrainedTypeParameter.ts, 10, 22)) if (!isPet(pet)) { ->isPet : Symbol(isPet, Decl(narrowingConstrainedTypeParameter.ts, 5, 1)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 11, 40)) +>isPet : Symbol(isPet, Decl(narrowingConstrainedTypeParameter.ts, 4, 1)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 10, 40)) throw new Error("Expected \"pet\" to be a Pet"); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } return voice(pet); ->voice : Symbol(voice, Decl(narrowingConstrainedTypeParameter.ts, 11, 50)) ->pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 11, 40)) +>voice : Symbol(voice, Decl(narrowingConstrainedTypeParameter.ts, 10, 50)) +>pet : Symbol(pet, Decl(narrowingConstrainedTypeParameter.ts, 10, 40)) } diff --git a/tests/baselines/reference/narrowingConstrainedTypeParameter.types b/tests/baselines/reference/narrowingConstrainedTypeParameter.types index 348716ab3c450..1c02ceeb8257b 100644 --- a/tests/baselines/reference/narrowingConstrainedTypeParameter.types +++ b/tests/baselines/reference/narrowingConstrainedTypeParameter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/narrowingConstrainedTypeParameter.ts === - // Repro from #10811 interface Pet { diff --git a/tests/baselines/reference/neverType.js b/tests/baselines/reference/neverType.js index a1e4c71f80386..e21a2fedf8ecc 100644 --- a/tests/baselines/reference/neverType.js +++ b/tests/baselines/reference/neverType.js @@ -1,6 +1,4 @@ //// [neverType.ts] - - function error(message: string): never { throw new Error(message); } diff --git a/tests/baselines/reference/neverType.symbols b/tests/baselines/reference/neverType.symbols index 4156934ddcc2a..f4e8329e7ea95 100644 --- a/tests/baselines/reference/neverType.symbols +++ b/tests/baselines/reference/neverType.symbols @@ -1,65 +1,63 @@ === tests/cases/conformance/types/never/neverType.ts === - - function error(message: string): never { >error : Symbol(error, Decl(neverType.ts, 0, 0)) ->message : Symbol(message, Decl(neverType.ts, 2, 15)) +>message : Symbol(message, Decl(neverType.ts, 0, 15)) throw new Error(message); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->message : Symbol(message, Decl(neverType.ts, 2, 15)) +>message : Symbol(message, Decl(neverType.ts, 0, 15)) } function errorVoid(message: string) { ->errorVoid : Symbol(errorVoid, Decl(neverType.ts, 4, 1)) ->message : Symbol(message, Decl(neverType.ts, 6, 19)) +>errorVoid : Symbol(errorVoid, Decl(neverType.ts, 2, 1)) +>message : Symbol(message, Decl(neverType.ts, 4, 19)) throw new Error(message); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->message : Symbol(message, Decl(neverType.ts, 6, 19)) +>message : Symbol(message, Decl(neverType.ts, 4, 19)) } function fail() { ->fail : Symbol(fail, Decl(neverType.ts, 8, 1)) +>fail : Symbol(fail, Decl(neverType.ts, 6, 1)) return error("Something failed"); >error : Symbol(error, Decl(neverType.ts, 0, 0)) } function failOrThrow(shouldFail: boolean) { ->failOrThrow : Symbol(failOrThrow, Decl(neverType.ts, 12, 1)) ->shouldFail : Symbol(shouldFail, Decl(neverType.ts, 14, 21)) +>failOrThrow : Symbol(failOrThrow, Decl(neverType.ts, 10, 1)) +>shouldFail : Symbol(shouldFail, Decl(neverType.ts, 12, 21)) if (shouldFail) { ->shouldFail : Symbol(shouldFail, Decl(neverType.ts, 14, 21)) +>shouldFail : Symbol(shouldFail, Decl(neverType.ts, 12, 21)) return fail(); ->fail : Symbol(fail, Decl(neverType.ts, 8, 1)) +>fail : Symbol(fail, Decl(neverType.ts, 6, 1)) } throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function infiniteLoop1() { ->infiniteLoop1 : Symbol(infiniteLoop1, Decl(neverType.ts, 19, 1)) +>infiniteLoop1 : Symbol(infiniteLoop1, Decl(neverType.ts, 17, 1)) while (true) { } } function infiniteLoop2(): never { ->infiniteLoop2 : Symbol(infiniteLoop2, Decl(neverType.ts, 24, 1)) +>infiniteLoop2 : Symbol(infiniteLoop2, Decl(neverType.ts, 22, 1)) while (true) { } } function move1(direction: "up" | "down") { ->move1 : Symbol(move1, Decl(neverType.ts, 29, 1)) ->direction : Symbol(direction, Decl(neverType.ts, 31, 15)) +>move1 : Symbol(move1, Decl(neverType.ts, 27, 1)) +>direction : Symbol(direction, Decl(neverType.ts, 29, 15)) switch (direction) { ->direction : Symbol(direction, Decl(neverType.ts, 31, 15)) +>direction : Symbol(direction, Decl(neverType.ts, 29, 15)) case "up": return 1; @@ -71,111 +69,111 @@ function move1(direction: "up" | "down") { } function move2(direction: "up" | "down") { ->move2 : Symbol(move2, Decl(neverType.ts, 39, 1)) ->direction : Symbol(direction, Decl(neverType.ts, 41, 15)) +>move2 : Symbol(move2, Decl(neverType.ts, 37, 1)) +>direction : Symbol(direction, Decl(neverType.ts, 39, 15)) return direction === "up" ? 1 : ->direction : Symbol(direction, Decl(neverType.ts, 41, 15)) +>direction : Symbol(direction, Decl(neverType.ts, 39, 15)) direction === "down" ? -1 : ->direction : Symbol(direction, Decl(neverType.ts, 41, 15)) +>direction : Symbol(direction, Decl(neverType.ts, 39, 15)) error("Should never get here"); >error : Symbol(error, Decl(neverType.ts, 0, 0)) } function check(x: T | undefined) { ->check : Symbol(check, Decl(neverType.ts, 45, 1)) ->T : Symbol(T, Decl(neverType.ts, 47, 15)) ->x : Symbol(x, Decl(neverType.ts, 47, 18)) ->T : Symbol(T, Decl(neverType.ts, 47, 15)) +>check : Symbol(check, Decl(neverType.ts, 43, 1)) +>T : Symbol(T, Decl(neverType.ts, 45, 15)) +>x : Symbol(x, Decl(neverType.ts, 45, 18)) +>T : Symbol(T, Decl(neverType.ts, 45, 15)) return x || error("Undefined value"); ->x : Symbol(x, Decl(neverType.ts, 47, 18)) +>x : Symbol(x, Decl(neverType.ts, 45, 18)) >error : Symbol(error, Decl(neverType.ts, 0, 0)) } class C { ->C : Symbol(C, Decl(neverType.ts, 49, 1)) +>C : Symbol(C, Decl(neverType.ts, 47, 1)) void1() { ->void1 : Symbol(C.void1, Decl(neverType.ts, 51, 9)) +>void1 : Symbol(C.void1, Decl(neverType.ts, 49, 9)) throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } void2() { ->void2 : Symbol(C.void2, Decl(neverType.ts, 54, 5)) +>void2 : Symbol(C.void2, Decl(neverType.ts, 52, 5)) while (true) {} } never1(): never { ->never1 : Symbol(C.never1, Decl(neverType.ts, 57, 5)) +>never1 : Symbol(C.never1, Decl(neverType.ts, 55, 5)) throw new Error(); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } never2(): never { ->never2 : Symbol(C.never2, Decl(neverType.ts, 60, 5)) +>never2 : Symbol(C.never2, Decl(neverType.ts, 58, 5)) while (true) {} } } function f1(x: string | number) { ->f1 : Symbol(f1, Decl(neverType.ts, 64, 1)) ->x : Symbol(x, Decl(neverType.ts, 66, 12)) +>f1 : Symbol(f1, Decl(neverType.ts, 62, 1)) +>x : Symbol(x, Decl(neverType.ts, 64, 12)) if (typeof x === "boolean") { ->x : Symbol(x, Decl(neverType.ts, 66, 12)) +>x : Symbol(x, Decl(neverType.ts, 64, 12)) x; // never ->x : Symbol(x, Decl(neverType.ts, 66, 12)) +>x : Symbol(x, Decl(neverType.ts, 64, 12)) } } function f2(x: string | number) { ->f2 : Symbol(f2, Decl(neverType.ts, 70, 1)) ->x : Symbol(x, Decl(neverType.ts, 72, 12)) +>f2 : Symbol(f2, Decl(neverType.ts, 68, 1)) +>x : Symbol(x, Decl(neverType.ts, 70, 12)) while (true) { if (typeof x === "boolean") { ->x : Symbol(x, Decl(neverType.ts, 72, 12)) +>x : Symbol(x, Decl(neverType.ts, 70, 12)) return x; // never ->x : Symbol(x, Decl(neverType.ts, 72, 12)) +>x : Symbol(x, Decl(neverType.ts, 70, 12)) } } } function test(cb: () => string) { ->test : Symbol(test, Decl(neverType.ts, 78, 1)) ->cb : Symbol(cb, Decl(neverType.ts, 80, 14)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) +>cb : Symbol(cb, Decl(neverType.ts, 78, 14)) let s = cb(); ->s : Symbol(s, Decl(neverType.ts, 81, 7)) ->cb : Symbol(cb, Decl(neverType.ts, 80, 14)) +>s : Symbol(s, Decl(neverType.ts, 79, 7)) +>cb : Symbol(cb, Decl(neverType.ts, 78, 14)) return s; ->s : Symbol(s, Decl(neverType.ts, 81, 7)) +>s : Symbol(s, Decl(neverType.ts, 79, 7)) } let errorCallback = () => error("Error callback"); ->errorCallback : Symbol(errorCallback, Decl(neverType.ts, 85, 3)) +>errorCallback : Symbol(errorCallback, Decl(neverType.ts, 83, 3)) >error : Symbol(error, Decl(neverType.ts, 0, 0)) test(() => "hello"); ->test : Symbol(test, Decl(neverType.ts, 78, 1)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) test(() => fail()); ->test : Symbol(test, Decl(neverType.ts, 78, 1)) ->fail : Symbol(fail, Decl(neverType.ts, 8, 1)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) +>fail : Symbol(fail, Decl(neverType.ts, 6, 1)) test(() => { throw new Error(); }) ->test : Symbol(test, Decl(neverType.ts, 78, 1)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) test(errorCallback); ->test : Symbol(test, Decl(neverType.ts, 78, 1)) ->errorCallback : Symbol(errorCallback, Decl(neverType.ts, 85, 3)) +>test : Symbol(test, Decl(neverType.ts, 76, 1)) +>errorCallback : Symbol(errorCallback, Decl(neverType.ts, 83, 3)) diff --git a/tests/baselines/reference/neverType.types b/tests/baselines/reference/neverType.types index 9555285e4be8c..efedf4629ac7e 100644 --- a/tests/baselines/reference/neverType.types +++ b/tests/baselines/reference/neverType.types @@ -1,6 +1,4 @@ === tests/cases/conformance/types/never/neverType.ts === - - function error(message: string): never { >error : (message: string) => never >message : string diff --git a/tests/baselines/reference/neverTypeErrors2.errors.txt b/tests/baselines/reference/neverTypeErrors2.errors.txt index 60e6947f44aac..5f9bb26344f60 100644 --- a/tests/baselines/reference/neverTypeErrors2.errors.txt +++ b/tests/baselines/reference/neverTypeErrors2.errors.txt @@ -1,16 +1,15 @@ -tests/cases/conformance/types/never/neverTypeErrors2.ts(4,5): error TS2322: Type '1' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(5,5): error TS2322: Type '"abc"' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(6,5): error TS2322: Type 'false' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(7,5): error TS2322: Type 'undefined' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(8,5): error TS2322: Type 'null' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(9,5): error TS2322: Type '{}' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(13,5): error TS2322: Type 'undefined' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(17,5): error TS2322: Type '1' is not assignable to type 'never'. -tests/cases/conformance/types/never/neverTypeErrors2.ts(20,16): error TS2534: A function returning 'never' cannot have a reachable end point. +tests/cases/conformance/types/never/neverTypeErrors2.ts(3,5): error TS2322: Type '1' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(4,5): error TS2322: Type '"abc"' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(5,5): error TS2322: Type 'false' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(6,5): error TS2322: Type 'undefined' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(7,5): error TS2322: Type 'null' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(8,5): error TS2322: Type '{}' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(12,5): error TS2322: Type 'undefined' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(16,5): error TS2322: Type '1' is not assignable to type 'never'. +tests/cases/conformance/types/never/neverTypeErrors2.ts(19,16): error TS2534: A function returning 'never' cannot have a reachable end point. ==== tests/cases/conformance/types/never/neverTypeErrors2.ts (9 errors) ==== - function f1() { let x: never; x = 1; diff --git a/tests/baselines/reference/neverTypeErrors2.js b/tests/baselines/reference/neverTypeErrors2.js index 18c92922bc1b7..70bdb4673cab3 100644 --- a/tests/baselines/reference/neverTypeErrors2.js +++ b/tests/baselines/reference/neverTypeErrors2.js @@ -1,5 +1,4 @@ //// [neverTypeErrors2.ts] - function f1() { let x: never; x = 1; diff --git a/tests/baselines/reference/newExpressionWithCast.errors.txt b/tests/baselines/reference/newExpressionWithCast.errors.txt index c8f44b96ae2e1..4fc4ee24d8c8b 100644 --- a/tests/baselines/reference/newExpressionWithCast.errors.txt +++ b/tests/baselines/reference/newExpressionWithCast.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/newExpressionWithCast.ts(4,12): error TS7009: 'new' expression, whose target lacks a construct signature, implicitly has an 'any' type. -tests/cases/compiler/newExpressionWithCast.ts(8,13): error TS2365: Operator '>' cannot be applied to types 'boolean' and 'void'. -tests/cases/compiler/newExpressionWithCast.ts(8,17): error TS1109: Expression expected. -tests/cases/compiler/newExpressionWithCast.ts(8,18): error TS2304: Cannot find name 'any'. +tests/cases/compiler/newExpressionWithCast.ts(3,12): error TS7009: 'new' expression, whose target lacks a construct signature, implicitly has an 'any' type. +tests/cases/compiler/newExpressionWithCast.ts(7,13): error TS2365: Operator '>' cannot be applied to types 'boolean' and 'void'. +tests/cases/compiler/newExpressionWithCast.ts(7,17): error TS1109: Expression expected. +tests/cases/compiler/newExpressionWithCast.ts(7,18): error TS2304: Cannot find name 'any'. ==== tests/cases/compiler/newExpressionWithCast.ts (4 errors) ==== - function Test() { } // valid but error with noImplicitAny var test = new Test(); diff --git a/tests/baselines/reference/newExpressionWithCast.js b/tests/baselines/reference/newExpressionWithCast.js index 8743d9b83bcaa..9be7105f68896 100644 --- a/tests/baselines/reference/newExpressionWithCast.js +++ b/tests/baselines/reference/newExpressionWithCast.js @@ -1,5 +1,4 @@ //// [newExpressionWithCast.ts] - function Test() { } // valid but error with noImplicitAny var test = new Test(); diff --git a/tests/baselines/reference/newNamesInGlobalAugmentations1.errors.txt b/tests/baselines/reference/newNamesInGlobalAugmentations1.errors.txt index f469885e4058d..aff01f3347e8d 100644 --- a/tests/baselines/reference/newNamesInGlobalAugmentations1.errors.txt +++ b/tests/baselines/reference/newNamesInGlobalAugmentations1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/f1.d.ts(13,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. +tests/cases/compiler/f1.d.ts(12,5): error TS2667: Imports are not permitted in module augmentations. Consider moving them to the enclosing external module. ==== tests/cases/compiler/f1.d.ts (1 errors) ==== - export {}; declare module M.M1 { @@ -20,7 +19,6 @@ tests/cases/compiler/f1.d.ts(13,5): error TS2667: Imports are not permitted in m } ==== tests/cases/compiler/main.ts (0 errors) ==== - Symbol.observable; new Cls().x let c = a + b + X; \ No newline at end of file diff --git a/tests/baselines/reference/newNamesInGlobalAugmentations1.js b/tests/baselines/reference/newNamesInGlobalAugmentations1.js index 0400f4c3751c4..283f03c02ee3e 100644 --- a/tests/baselines/reference/newNamesInGlobalAugmentations1.js +++ b/tests/baselines/reference/newNamesInGlobalAugmentations1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/newNamesInGlobalAugmentations1.ts] //// //// [f1.d.ts] - export {}; declare module M.M1 { @@ -17,7 +16,6 @@ declare global { } //// [main.ts] - Symbol.observable; new Cls().x let c = a + b + X; diff --git a/tests/baselines/reference/newOperatorConformance.js b/tests/baselines/reference/newOperatorConformance.js index 3b84cbd669880..46a1f3c7caced 100644 --- a/tests/baselines/reference/newOperatorConformance.js +++ b/tests/baselines/reference/newOperatorConformance.js @@ -1,5 +1,4 @@ //// [newOperatorConformance.ts] - class C0 { } diff --git a/tests/baselines/reference/newOperatorConformance.symbols b/tests/baselines/reference/newOperatorConformance.symbols index 8467e1741fced..aa3fe289166c6 100644 --- a/tests/baselines/reference/newOperatorConformance.symbols +++ b/tests/baselines/reference/newOperatorConformance.symbols @@ -1,135 +1,134 @@ === tests/cases/conformance/expressions/newOperator/newOperatorConformance.ts === - class C0 { >C0 : Symbol(C0, Decl(newOperatorConformance.ts, 0, 0)) } class C1 { ->C1 : Symbol(C1, Decl(newOperatorConformance.ts, 3, 1)) +>C1 : Symbol(C1, Decl(newOperatorConformance.ts, 2, 1)) constructor(n: number, s: string) { } ->n : Symbol(n, Decl(newOperatorConformance.ts, 5, 16)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 5, 26)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 4, 16)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 4, 26)) } class T { ->T : Symbol(T, Decl(newOperatorConformance.ts, 6, 1)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 8, 8)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 5, 1)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 7, 8)) constructor(n?: T) { } ->n : Symbol(n, Decl(newOperatorConformance.ts, 9, 16)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 8, 8)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 8, 16)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 7, 8)) } var anyCtor: { ->anyCtor : Symbol(anyCtor, Decl(newOperatorConformance.ts, 12, 3)) +>anyCtor : Symbol(anyCtor, Decl(newOperatorConformance.ts, 11, 3)) new (): any; }; var anyCtor1: { ->anyCtor1 : Symbol(anyCtor1, Decl(newOperatorConformance.ts, 16, 3)) +>anyCtor1 : Symbol(anyCtor1, Decl(newOperatorConformance.ts, 15, 3)) new (n): any; ->n : Symbol(n, Decl(newOperatorConformance.ts, 17, 9)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 16, 9)) }; interface nestedCtor { ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) new (): nestedCtor; ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) } var nestedCtor: nestedCtor; ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) // Construct expression with no parentheses for construct signature with 0 parameters var a = new C0; ->a : Symbol(a, Decl(newOperatorConformance.ts, 26, 3), Decl(newOperatorConformance.ts, 27, 3)) +>a : Symbol(a, Decl(newOperatorConformance.ts, 25, 3), Decl(newOperatorConformance.ts, 26, 3)) >C0 : Symbol(C0, Decl(newOperatorConformance.ts, 0, 0)) var a: C0; ->a : Symbol(a, Decl(newOperatorConformance.ts, 26, 3), Decl(newOperatorConformance.ts, 27, 3)) +>a : Symbol(a, Decl(newOperatorConformance.ts, 25, 3), Decl(newOperatorConformance.ts, 26, 3)) >C0 : Symbol(C0, Decl(newOperatorConformance.ts, 0, 0)) // Generic construct expression with no parentheses var c1 = new T; ->c1 : Symbol(c1, Decl(newOperatorConformance.ts, 31, 3), Decl(newOperatorConformance.ts, 32, 3)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 6, 1)) +>c1 : Symbol(c1, Decl(newOperatorConformance.ts, 30, 3), Decl(newOperatorConformance.ts, 31, 3)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 5, 1)) var c1: T<{}>; ->c1 : Symbol(c1, Decl(newOperatorConformance.ts, 31, 3), Decl(newOperatorConformance.ts, 32, 3)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 6, 1)) +>c1 : Symbol(c1, Decl(newOperatorConformance.ts, 30, 3), Decl(newOperatorConformance.ts, 31, 3)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 5, 1)) // Construct expression where constructor is of type 'any' with no parentheses var d = new anyCtor; ->d : Symbol(d, Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 36, 3), Decl(newOperatorConformance.ts, 39, 3)) ->anyCtor : Symbol(anyCtor, Decl(newOperatorConformance.ts, 12, 3)) +>d : Symbol(d, Decl(newOperatorConformance.ts, 34, 3), Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 38, 3)) +>anyCtor : Symbol(anyCtor, Decl(newOperatorConformance.ts, 11, 3)) var d: any; ->d : Symbol(d, Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 36, 3), Decl(newOperatorConformance.ts, 39, 3)) +>d : Symbol(d, Decl(newOperatorConformance.ts, 34, 3), Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 38, 3)) // Construct expression where constructor is of type 'any' with > 1 arg var d = new anyCtor1(undefined); ->d : Symbol(d, Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 36, 3), Decl(newOperatorConformance.ts, 39, 3)) ->anyCtor1 : Symbol(anyCtor1, Decl(newOperatorConformance.ts, 16, 3)) +>d : Symbol(d, Decl(newOperatorConformance.ts, 34, 3), Decl(newOperatorConformance.ts, 35, 3), Decl(newOperatorConformance.ts, 38, 3)) +>anyCtor1 : Symbol(anyCtor1, Decl(newOperatorConformance.ts, 15, 3)) >undefined : Symbol(undefined) // Construct expression of type where apparent type has a construct signature with 0 arguments function newFn1(s: T) { ->newFn1 : Symbol(newFn1, Decl(newOperatorConformance.ts, 39, 32)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 42, 16)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 42, 46)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 42, 16)) +>newFn1 : Symbol(newFn1, Decl(newOperatorConformance.ts, 38, 32)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 41, 16)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 41, 46)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 41, 16)) var p = new s; ->p : Symbol(p, Decl(newOperatorConformance.ts, 43, 7), Decl(newOperatorConformance.ts, 44, 7)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 42, 46)) +>p : Symbol(p, Decl(newOperatorConformance.ts, 42, 7), Decl(newOperatorConformance.ts, 43, 7)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 41, 46)) var p: number; ->p : Symbol(p, Decl(newOperatorConformance.ts, 43, 7), Decl(newOperatorConformance.ts, 44, 7)) +>p : Symbol(p, Decl(newOperatorConformance.ts, 42, 7), Decl(newOperatorConformance.ts, 43, 7)) } // Construct expression of type where apparent type has a construct signature with 1 arguments function newFn2(s: T) { ->newFn2 : Symbol(newFn2, Decl(newOperatorConformance.ts, 45, 1)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 48, 16)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 48, 33)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 48, 54)) ->T : Symbol(T, Decl(newOperatorConformance.ts, 48, 16)) +>newFn2 : Symbol(newFn2, Decl(newOperatorConformance.ts, 44, 1)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 47, 16)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 47, 33)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 47, 54)) +>T : Symbol(T, Decl(newOperatorConformance.ts, 47, 16)) var p = new s(32); ->p : Symbol(p, Decl(newOperatorConformance.ts, 49, 7), Decl(newOperatorConformance.ts, 50, 7)) ->s : Symbol(s, Decl(newOperatorConformance.ts, 48, 54)) +>p : Symbol(p, Decl(newOperatorConformance.ts, 48, 7), Decl(newOperatorConformance.ts, 49, 7)) +>s : Symbol(s, Decl(newOperatorConformance.ts, 47, 54)) var p: string; ->p : Symbol(p, Decl(newOperatorConformance.ts, 49, 7), Decl(newOperatorConformance.ts, 50, 7)) +>p : Symbol(p, Decl(newOperatorConformance.ts, 48, 7), Decl(newOperatorConformance.ts, 49, 7)) } // Construct expression of void returning function function fnVoid(): void { } ->fnVoid : Symbol(fnVoid, Decl(newOperatorConformance.ts, 51, 1)) +>fnVoid : Symbol(fnVoid, Decl(newOperatorConformance.ts, 50, 1)) var t = new fnVoid(); ->t : Symbol(t, Decl(newOperatorConformance.ts, 55, 3), Decl(newOperatorConformance.ts, 56, 3)) ->fnVoid : Symbol(fnVoid, Decl(newOperatorConformance.ts, 51, 1)) +>t : Symbol(t, Decl(newOperatorConformance.ts, 54, 3), Decl(newOperatorConformance.ts, 55, 3)) +>fnVoid : Symbol(fnVoid, Decl(newOperatorConformance.ts, 50, 1)) var t: any; ->t : Symbol(t, Decl(newOperatorConformance.ts, 55, 3), Decl(newOperatorConformance.ts, 56, 3)) +>t : Symbol(t, Decl(newOperatorConformance.ts, 54, 3), Decl(newOperatorConformance.ts, 55, 3)) // Chained new expressions var nested = new (new (new nestedCtor())())(); ->nested : Symbol(nested, Decl(newOperatorConformance.ts, 59, 3)) ->nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 18, 2), Decl(newOperatorConformance.ts, 23, 3)) +>nested : Symbol(nested, Decl(newOperatorConformance.ts, 58, 3)) +>nestedCtor : Symbol(nestedCtor, Decl(newOperatorConformance.ts, 17, 2), Decl(newOperatorConformance.ts, 22, 3)) var n = new nested(); ->n : Symbol(n, Decl(newOperatorConformance.ts, 60, 3), Decl(newOperatorConformance.ts, 61, 3)) ->nested : Symbol(nested, Decl(newOperatorConformance.ts, 59, 3)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 59, 3), Decl(newOperatorConformance.ts, 60, 3)) +>nested : Symbol(nested, Decl(newOperatorConformance.ts, 58, 3)) var n = new nested(); ->n : Symbol(n, Decl(newOperatorConformance.ts, 60, 3), Decl(newOperatorConformance.ts, 61, 3)) ->nested : Symbol(nested, Decl(newOperatorConformance.ts, 59, 3)) +>n : Symbol(n, Decl(newOperatorConformance.ts, 59, 3), Decl(newOperatorConformance.ts, 60, 3)) +>nested : Symbol(nested, Decl(newOperatorConformance.ts, 58, 3)) diff --git a/tests/baselines/reference/newOperatorConformance.types b/tests/baselines/reference/newOperatorConformance.types index c7fb0125a1ae4..6a78087167749 100644 --- a/tests/baselines/reference/newOperatorConformance.types +++ b/tests/baselines/reference/newOperatorConformance.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/newOperator/newOperatorConformance.ts === - class C0 { >C0 : C0 diff --git a/tests/baselines/reference/newOperatorErrorCases.errors.txt b/tests/baselines/reference/newOperatorErrorCases.errors.txt index b2947a1d21832..c41efaac28995 100644 --- a/tests/baselines/reference/newOperatorErrorCases.errors.txt +++ b/tests/baselines/reference/newOperatorErrorCases.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(27,16): error TS1005: ',' expected. -tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(27,16): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(32,23): error TS1005: '(' expected. -tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(37,9): error TS2350: Only a void function can be called with the 'new' keyword. +tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(26,16): error TS1005: ',' expected. +tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(26,16): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(31,23): error TS1005: '(' expected. +tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(36,9): error TS2350: Only a void function can be called with the 'new' keyword. ==== tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts (4 errors) ==== - class C0 { } diff --git a/tests/baselines/reference/newOperatorErrorCases.js b/tests/baselines/reference/newOperatorErrorCases.js index 6d57f9a090e6e..5f179fece7777 100644 --- a/tests/baselines/reference/newOperatorErrorCases.js +++ b/tests/baselines/reference/newOperatorErrorCases.js @@ -1,5 +1,4 @@ //// [newOperatorErrorCases.ts] - class C0 { } diff --git a/tests/baselines/reference/newWithSpread.errors.txt b/tests/baselines/reference/newWithSpread.errors.txt index 293c7054e4c2f..e91a6757ead3e 100644 --- a/tests/baselines/reference/newWithSpread.errors.txt +++ b/tests/baselines/reference/newWithSpread.errors.txt @@ -1,33 +1,32 @@ +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(36,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(37,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(38,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(41,8): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(42,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(40,8): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(41,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(45,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(46,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(47,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(50,15): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(51,15): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(52,15): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(55,17): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(56,17): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(57,17): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(60,18): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(61,18): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(62,18): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(65,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(66,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(67,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(70,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(71,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(72,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(75,20): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(76,20): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(77,20): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(80,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(81,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(82,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(85,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(86,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(87,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(90,27): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(91,27): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(92,27): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(95,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(96,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(97,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher. ==== tests/cases/conformance/expressions/functionCalls/newWithSpread.ts (26 errors) ==== - function f(x: number, y: number, ...z: string[]) { } diff --git a/tests/baselines/reference/newWithSpread.js b/tests/baselines/reference/newWithSpread.js index c6ea3b44c15e8..f08902b14be97 100644 --- a/tests/baselines/reference/newWithSpread.js +++ b/tests/baselines/reference/newWithSpread.js @@ -1,5 +1,4 @@ //// [newWithSpread.ts] - function f(x: number, y: number, ...z: string[]) { } diff --git a/tests/baselines/reference/newWithSpreadES5.js b/tests/baselines/reference/newWithSpreadES5.js index 125ac9f0412dd..a74a5a729a65e 100644 --- a/tests/baselines/reference/newWithSpreadES5.js +++ b/tests/baselines/reference/newWithSpreadES5.js @@ -1,5 +1,4 @@ //// [newWithSpreadES5.ts] - function f(x: number, y: number, ...z: string[]) { } diff --git a/tests/baselines/reference/newWithSpreadES5.symbols b/tests/baselines/reference/newWithSpreadES5.symbols index 7db4e6f106360..dc0b56a8c271d 100644 --- a/tests/baselines/reference/newWithSpreadES5.symbols +++ b/tests/baselines/reference/newWithSpreadES5.symbols @@ -1,84 +1,83 @@ === tests/cases/conformance/expressions/functionCalls/newWithSpreadES5.ts === - function f(x: number, y: number, ...z: string[]) { >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->x : Symbol(x, Decl(newWithSpreadES5.ts, 1, 11)) ->y : Symbol(y, Decl(newWithSpreadES5.ts, 1, 21)) ->z : Symbol(z, Decl(newWithSpreadES5.ts, 1, 32)) +>x : Symbol(x, Decl(newWithSpreadES5.ts, 0, 11)) +>y : Symbol(y, Decl(newWithSpreadES5.ts, 0, 21)) +>z : Symbol(z, Decl(newWithSpreadES5.ts, 0, 32)) } function f2(...x: string[]) {} ->f2 : Symbol(f2, Decl(newWithSpreadES5.ts, 2, 1)) ->x : Symbol(x, Decl(newWithSpreadES5.ts, 4, 12)) +>f2 : Symbol(f2, Decl(newWithSpreadES5.ts, 1, 1)) +>x : Symbol(x, Decl(newWithSpreadES5.ts, 3, 12)) interface A { ->A : Symbol(A, Decl(newWithSpreadES5.ts, 4, 30)) +>A : Symbol(A, Decl(newWithSpreadES5.ts, 3, 30)) f: { ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new (x: number, y: number, ...z: string[]); ->x : Symbol(x, Decl(newWithSpreadES5.ts, 8, 13)) ->y : Symbol(y, Decl(newWithSpreadES5.ts, 8, 23)) ->z : Symbol(z, Decl(newWithSpreadES5.ts, 8, 34)) +>x : Symbol(x, Decl(newWithSpreadES5.ts, 7, 13)) +>y : Symbol(y, Decl(newWithSpreadES5.ts, 7, 23)) +>z : Symbol(z, Decl(newWithSpreadES5.ts, 7, 34)) } } class B { ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) constructor(x: number, y: number, ...z: string[]) {} ->x : Symbol(x, Decl(newWithSpreadES5.ts, 13, 16)) ->y : Symbol(y, Decl(newWithSpreadES5.ts, 13, 26)) ->z : Symbol(z, Decl(newWithSpreadES5.ts, 13, 37)) +>x : Symbol(x, Decl(newWithSpreadES5.ts, 12, 16)) +>y : Symbol(y, Decl(newWithSpreadES5.ts, 12, 26)) +>z : Symbol(z, Decl(newWithSpreadES5.ts, 12, 37)) } interface C { ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) "a-b": typeof B; ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) } interface D { ->D : Symbol(D, Decl(newWithSpreadES5.ts, 18, 1)) +>D : Symbol(D, Decl(newWithSpreadES5.ts, 17, 1)) 1: typeof B; ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) } var a: string[]; ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) var b: A; ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->A : Symbol(A, Decl(newWithSpreadES5.ts, 4, 30)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>A : Symbol(A, Decl(newWithSpreadES5.ts, 3, 30)) var c: C; ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) var d: A[]; ->d : Symbol(d, Decl(newWithSpreadES5.ts, 27, 3)) ->A : Symbol(A, Decl(newWithSpreadES5.ts, 4, 30)) +>d : Symbol(d, Decl(newWithSpreadES5.ts, 26, 3)) +>A : Symbol(A, Decl(newWithSpreadES5.ts, 3, 30)) var e: { [key: string]: A }; ->e : Symbol(e, Decl(newWithSpreadES5.ts, 28, 3)) ->key : Symbol(key, Decl(newWithSpreadES5.ts, 28, 10)) ->A : Symbol(A, Decl(newWithSpreadES5.ts, 4, 30)) +>e : Symbol(e, Decl(newWithSpreadES5.ts, 27, 3)) +>key : Symbol(key, Decl(newWithSpreadES5.ts, 27, 10)) +>A : Symbol(A, Decl(newWithSpreadES5.ts, 3, 30)) var g: C[]; ->g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3)) ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>g : Symbol(g, Decl(newWithSpreadES5.ts, 28, 3)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) var h: { [key: string]: C }; ->h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3)) ->key : Symbol(key, Decl(newWithSpreadES5.ts, 30, 10)) ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>h : Symbol(h, Decl(newWithSpreadES5.ts, 29, 3)) +>key : Symbol(key, Decl(newWithSpreadES5.ts, 29, 10)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) var i: C[][]; ->i : Symbol(i, Decl(newWithSpreadES5.ts, 31, 3)) ->C : Symbol(C, Decl(newWithSpreadES5.ts, 14, 1)) +>i : Symbol(i, Decl(newWithSpreadES5.ts, 30, 3)) +>C : Symbol(C, Decl(newWithSpreadES5.ts, 13, 1)) // Basic expression new f(1, 2, "string"); @@ -86,22 +85,22 @@ new f(1, 2, "string"); new f(1, 2, ...a); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new f(1, 2, ...a, "string"); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Multiple spreads arguments new f2(...a, ...a); ->f2 : Symbol(f2, Decl(newWithSpreadES5.ts, 2, 1)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>f2 : Symbol(f2, Decl(newWithSpreadES5.ts, 1, 1)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new f(1 ,2, ...a, ...a); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Call expression new f(1, 2, "string")(); @@ -109,165 +108,165 @@ new f(1, 2, "string")(); new f(1, 2, ...a)(); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new f(1, 2, ...a, "string")(); >f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Property access expression new b.f(1, 2, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new b.f(1, 2, ...a); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new b.f(1, 2, ...a, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Parenthesised expression new (b.f)(1, 2, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new (b.f)(1, 2, ...a); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new (b.f)(1, 2, ...a, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->b : Symbol(b, Decl(newWithSpreadES5.ts, 25, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression new d[1].f(1, 2, "string"); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->d : Symbol(d, Decl(newWithSpreadES5.ts, 27, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>d : Symbol(d, Decl(newWithSpreadES5.ts, 26, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new d[1].f(1, 2, ...a); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->d : Symbol(d, Decl(newWithSpreadES5.ts, 27, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>d : Symbol(d, Decl(newWithSpreadES5.ts, 26, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new d[1].f(1, 2, ...a, "string"); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->d : Symbol(d, Decl(newWithSpreadES5.ts, 27, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>d : Symbol(d, Decl(newWithSpreadES5.ts, 26, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression with a punctuated key new e["a-b"].f(1, 2, "string"); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->e : Symbol(e, Decl(newWithSpreadES5.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>e : Symbol(e, Decl(newWithSpreadES5.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) new e["a-b"].f(1, 2, ...a); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->e : Symbol(e, Decl(newWithSpreadES5.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>e : Symbol(e, Decl(newWithSpreadES5.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new e["a-b"].f(1, 2, ...a, "string"); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->e : Symbol(e, Decl(newWithSpreadES5.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES5.ts, 6, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>e : Symbol(e, Decl(newWithSpreadES5.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Basic expression new B(1, 2, "string"); ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) new B(1, 2, ...a); ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new B(1, 2, ...a, "string"); ->B : Symbol(B, Decl(newWithSpreadES5.ts, 10, 1)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>B : Symbol(B, Decl(newWithSpreadES5.ts, 9, 1)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Property access expression new c["a-b"](1, 2, "string"); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) new c["a-b"](1, 2, ...a); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new c["a-b"](1, 2, ...a, "string"); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Parenthesised expression new (c["a-b"])(1, 2, "string"); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) new (c["a-b"])(1, 2, ...a); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new (c["a-b"])(1, 2, ...a, "string"); ->c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>c : Symbol(c, Decl(newWithSpreadES5.ts, 25, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression new g[1]["a-b"](1, 2, "string"); ->g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) +>g : Symbol(g, Decl(newWithSpreadES5.ts, 28, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) new g[1]["a-b"](1, 2, ...a); ->g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>g : Symbol(g, Decl(newWithSpreadES5.ts, 28, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new g[1]["a-b"](1, 2, ...a, "string"); ->g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>g : Symbol(g, Decl(newWithSpreadES5.ts, 28, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression with a punctuated key new h["a-b"]["a-b"](1, 2, "string"); ->h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) +>h : Symbol(h, Decl(newWithSpreadES5.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) new h["a-b"]["a-b"](1, 2, ...a); ->h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>h : Symbol(h, Decl(newWithSpreadES5.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new h["a-b"]["a-b"](1, 2, ...a, "string"); ->h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>h : Symbol(h, Decl(newWithSpreadES5.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 15, 13)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) // Element access expression with a number new i["a-b"][1](1, 2, "string"); ->i : Symbol(i, Decl(newWithSpreadES5.ts, 31, 3)) +>i : Symbol(i, Decl(newWithSpreadES5.ts, 30, 3)) new i["a-b"][1](1, 2, ...a); ->i : Symbol(i, Decl(newWithSpreadES5.ts, 31, 3)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>i : Symbol(i, Decl(newWithSpreadES5.ts, 30, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) new i["a-b"][1](1, 2, ...a, "string"); ->i : Symbol(i, Decl(newWithSpreadES5.ts, 31, 3)) ->a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3)) +>i : Symbol(i, Decl(newWithSpreadES5.ts, 30, 3)) +>a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3)) diff --git a/tests/baselines/reference/newWithSpreadES5.types b/tests/baselines/reference/newWithSpreadES5.types index dfa45b33ee1b5..ce173e071d8a4 100644 --- a/tests/baselines/reference/newWithSpreadES5.types +++ b/tests/baselines/reference/newWithSpreadES5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/functionCalls/newWithSpreadES5.ts === - function f(x: number, y: number, ...z: string[]) { >f : (x: number, y: number, ...z: string[]) => void >x : number diff --git a/tests/baselines/reference/newWithSpreadES6.js b/tests/baselines/reference/newWithSpreadES6.js index dca5264cb3f63..ab9c17d5d66ea 100644 --- a/tests/baselines/reference/newWithSpreadES6.js +++ b/tests/baselines/reference/newWithSpreadES6.js @@ -1,5 +1,4 @@ //// [newWithSpreadES6.ts] - function f(x: number, y: number, ...z: string[]) { } diff --git a/tests/baselines/reference/newWithSpreadES6.symbols b/tests/baselines/reference/newWithSpreadES6.symbols index 946aeeb5c1ada..98c58e4045130 100644 --- a/tests/baselines/reference/newWithSpreadES6.symbols +++ b/tests/baselines/reference/newWithSpreadES6.symbols @@ -1,85 +1,84 @@ === tests/cases/conformance/expressions/functionCalls/newWithSpreadES6.ts === - function f(x: number, y: number, ...z: string[]) { >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->x : Symbol(x, Decl(newWithSpreadES6.ts, 1, 11)) ->y : Symbol(y, Decl(newWithSpreadES6.ts, 1, 21)) ->z : Symbol(z, Decl(newWithSpreadES6.ts, 1, 32)) +>x : Symbol(x, Decl(newWithSpreadES6.ts, 0, 11)) +>y : Symbol(y, Decl(newWithSpreadES6.ts, 0, 21)) +>z : Symbol(z, Decl(newWithSpreadES6.ts, 0, 32)) } function f2(...x: string[]) { ->f2 : Symbol(f2, Decl(newWithSpreadES6.ts, 2, 1)) ->x : Symbol(x, Decl(newWithSpreadES6.ts, 4, 12)) +>f2 : Symbol(f2, Decl(newWithSpreadES6.ts, 1, 1)) +>x : Symbol(x, Decl(newWithSpreadES6.ts, 3, 12)) } interface A { ->A : Symbol(A, Decl(newWithSpreadES6.ts, 5, 1)) +>A : Symbol(A, Decl(newWithSpreadES6.ts, 4, 1)) f: { ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new (x: number, y: number, ...z: string[]); ->x : Symbol(x, Decl(newWithSpreadES6.ts, 9, 13)) ->y : Symbol(y, Decl(newWithSpreadES6.ts, 9, 23)) ->z : Symbol(z, Decl(newWithSpreadES6.ts, 9, 34)) +>x : Symbol(x, Decl(newWithSpreadES6.ts, 8, 13)) +>y : Symbol(y, Decl(newWithSpreadES6.ts, 8, 23)) +>z : Symbol(z, Decl(newWithSpreadES6.ts, 8, 34)) } } class B { ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) constructor(x: number, y: number, ...z: string[]) {} ->x : Symbol(x, Decl(newWithSpreadES6.ts, 14, 16)) ->y : Symbol(y, Decl(newWithSpreadES6.ts, 14, 26)) ->z : Symbol(z, Decl(newWithSpreadES6.ts, 14, 37)) +>x : Symbol(x, Decl(newWithSpreadES6.ts, 13, 16)) +>y : Symbol(y, Decl(newWithSpreadES6.ts, 13, 26)) +>z : Symbol(z, Decl(newWithSpreadES6.ts, 13, 37)) } interface C { ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) "a-b": typeof B; ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) } interface D { ->D : Symbol(D, Decl(newWithSpreadES6.ts, 19, 1)) +>D : Symbol(D, Decl(newWithSpreadES6.ts, 18, 1)) 1: typeof B; ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) } var a: string[]; ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) var b: A; ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->A : Symbol(A, Decl(newWithSpreadES6.ts, 5, 1)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>A : Symbol(A, Decl(newWithSpreadES6.ts, 4, 1)) var c: C; ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) var d: A[]; ->d : Symbol(d, Decl(newWithSpreadES6.ts, 28, 3)) ->A : Symbol(A, Decl(newWithSpreadES6.ts, 5, 1)) +>d : Symbol(d, Decl(newWithSpreadES6.ts, 27, 3)) +>A : Symbol(A, Decl(newWithSpreadES6.ts, 4, 1)) var e: { [key: string]: A }; ->e : Symbol(e, Decl(newWithSpreadES6.ts, 29, 3)) ->key : Symbol(key, Decl(newWithSpreadES6.ts, 29, 10)) ->A : Symbol(A, Decl(newWithSpreadES6.ts, 5, 1)) +>e : Symbol(e, Decl(newWithSpreadES6.ts, 28, 3)) +>key : Symbol(key, Decl(newWithSpreadES6.ts, 28, 10)) +>A : Symbol(A, Decl(newWithSpreadES6.ts, 4, 1)) var g: C[]; ->g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3)) ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>g : Symbol(g, Decl(newWithSpreadES6.ts, 29, 3)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) var h: { [key: string]: C }; ->h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3)) ->key : Symbol(key, Decl(newWithSpreadES6.ts, 31, 10)) ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>h : Symbol(h, Decl(newWithSpreadES6.ts, 30, 3)) +>key : Symbol(key, Decl(newWithSpreadES6.ts, 30, 10)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) var i: C[][]; ->i : Symbol(i, Decl(newWithSpreadES6.ts, 32, 3)) ->C : Symbol(C, Decl(newWithSpreadES6.ts, 15, 1)) +>i : Symbol(i, Decl(newWithSpreadES6.ts, 31, 3)) +>C : Symbol(C, Decl(newWithSpreadES6.ts, 14, 1)) // Basic expression new f(1, 2, "string"); @@ -87,22 +86,22 @@ new f(1, 2, "string"); new f(1, 2, ...a); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new f(1, 2, ...a, "string"); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Multiple spreads arguments new f2(...a, ...a); ->f2 : Symbol(f2, Decl(newWithSpreadES6.ts, 2, 1)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>f2 : Symbol(f2, Decl(newWithSpreadES6.ts, 1, 1)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new f(1 ,2, ...a, ...a); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Call expression new f(1, 2, "string")(); @@ -110,165 +109,165 @@ new f(1, 2, "string")(); new f(1, 2, ...a)(); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new f(1, 2, ...a, "string")(); >f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Property access expression new b.f(1, 2, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new b.f(1, 2, ...a); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new b.f(1, 2, ...a, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Parenthesised expression new (b.f)(1, 2, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new (b.f)(1, 2, ...a); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new (b.f)(1, 2, ...a, "string"); ->b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->b : Symbol(b, Decl(newWithSpreadES6.ts, 26, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression new d[1].f(1, 2, "string"); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->d : Symbol(d, Decl(newWithSpreadES6.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>d : Symbol(d, Decl(newWithSpreadES6.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new d[1].f(1, 2, ...a); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->d : Symbol(d, Decl(newWithSpreadES6.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>d : Symbol(d, Decl(newWithSpreadES6.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new d[1].f(1, 2, ...a, "string"); ->d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->d : Symbol(d, Decl(newWithSpreadES6.ts, 28, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>d : Symbol(d, Decl(newWithSpreadES6.ts, 27, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression with a punctuated key new e["a-b"].f(1, 2, "string"); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->e : Symbol(e, Decl(newWithSpreadES6.ts, 29, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>e : Symbol(e, Decl(newWithSpreadES6.ts, 28, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) new e["a-b"].f(1, 2, ...a); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->e : Symbol(e, Decl(newWithSpreadES6.ts, 29, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>e : Symbol(e, Decl(newWithSpreadES6.ts, 28, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new e["a-b"].f(1, 2, ...a, "string"); ->e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->e : Symbol(e, Decl(newWithSpreadES6.ts, 29, 3)) ->f : Symbol(A.f, Decl(newWithSpreadES6.ts, 7, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>e : Symbol(e, Decl(newWithSpreadES6.ts, 28, 3)) +>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Basic expression new B(1, 2, "string"); ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) new B(1, 2, ...a); ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new B(1, 2, ...a, "string"); ->B : Symbol(B, Decl(newWithSpreadES6.ts, 11, 1)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>B : Symbol(B, Decl(newWithSpreadES6.ts, 10, 1)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Property access expression new c["a-b"](1, 2, "string"); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) new c["a-b"](1, 2, ...a); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new c["a-b"](1, 2, ...a, "string"); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Parenthesised expression new (c["a-b"])(1, 2, "string"); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) new (c["a-b"])(1, 2, ...a); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new (c["a-b"])(1, 2, ...a, "string"); ->c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>c : Symbol(c, Decl(newWithSpreadES6.ts, 26, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression new g[1]["a-b"](1, 2, "string"); ->g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) +>g : Symbol(g, Decl(newWithSpreadES6.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) new g[1]["a-b"](1, 2, ...a); ->g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>g : Symbol(g, Decl(newWithSpreadES6.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new g[1]["a-b"](1, 2, ...a, "string"); ->g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>g : Symbol(g, Decl(newWithSpreadES6.ts, 29, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression with a punctuated key new h["a-b"]["a-b"](1, 2, "string"); ->h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) +>h : Symbol(h, Decl(newWithSpreadES6.ts, 30, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) new h["a-b"]["a-b"](1, 2, ...a); ->h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>h : Symbol(h, Decl(newWithSpreadES6.ts, 30, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new h["a-b"]["a-b"](1, 2, ...a, "string"); ->h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3)) ->"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>h : Symbol(h, Decl(newWithSpreadES6.ts, 30, 3)) +>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 16, 13)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) // Element access expression with a number new i["a-b"][1](1, 2, "string"); ->i : Symbol(i, Decl(newWithSpreadES6.ts, 32, 3)) +>i : Symbol(i, Decl(newWithSpreadES6.ts, 31, 3)) new i["a-b"][1](1, 2, ...a); ->i : Symbol(i, Decl(newWithSpreadES6.ts, 32, 3)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>i : Symbol(i, Decl(newWithSpreadES6.ts, 31, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) new i["a-b"][1](1, 2, ...a, "string"); ->i : Symbol(i, Decl(newWithSpreadES6.ts, 32, 3)) ->a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3)) +>i : Symbol(i, Decl(newWithSpreadES6.ts, 31, 3)) +>a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3)) diff --git a/tests/baselines/reference/newWithSpreadES6.types b/tests/baselines/reference/newWithSpreadES6.types index 587e7683e6a83..8567d04f260a3 100644 --- a/tests/baselines/reference/newWithSpreadES6.types +++ b/tests/baselines/reference/newWithSpreadES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/functionCalls/newWithSpreadES6.ts === - function f(x: number, y: number, ...z: string[]) { >f : (x: number, y: number, ...z: string[]) => void >x : number diff --git a/tests/baselines/reference/noBundledEmitFromNodeModules.js b/tests/baselines/reference/noBundledEmitFromNodeModules.js index 67216a408af51..b52a7ff9a376d 100644 --- a/tests/baselines/reference/noBundledEmitFromNodeModules.js +++ b/tests/baselines/reference/noBundledEmitFromNodeModules.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/noBundledEmitFromNodeModules.ts] //// //// [index.ts] - export class C {} //// [a.ts] diff --git a/tests/baselines/reference/noBundledEmitFromNodeModules.symbols b/tests/baselines/reference/noBundledEmitFromNodeModules.symbols index a1f6c67e4b4c3..d82770274d9ab 100644 --- a/tests/baselines/reference/noBundledEmitFromNodeModules.symbols +++ b/tests/baselines/reference/noBundledEmitFromNodeModules.symbols @@ -3,7 +3,6 @@ import { C } from "projB"; >C : Symbol(C, Decl(a.ts, 0, 8)) === /node_modules/projB/index.ts === - export class C {} >C : Symbol(C, Decl(index.ts, 0, 0)) diff --git a/tests/baselines/reference/noBundledEmitFromNodeModules.types b/tests/baselines/reference/noBundledEmitFromNodeModules.types index a11bad24aaf23..3c598921ee43d 100644 --- a/tests/baselines/reference/noBundledEmitFromNodeModules.types +++ b/tests/baselines/reference/noBundledEmitFromNodeModules.types @@ -3,7 +3,6 @@ import { C } from "projB"; >C : typeof C === /node_modules/projB/index.ts === - export class C {} >C : C diff --git a/tests/baselines/reference/noCatchBlock.js b/tests/baselines/reference/noCatchBlock.js index ecc9c7f8c7ea7..ef9ff6cb1de0c 100644 --- a/tests/baselines/reference/noCatchBlock.js +++ b/tests/baselines/reference/noCatchBlock.js @@ -1,5 +1,4 @@ //// [noCatchBlock.ts] - try { // ... } finally { diff --git a/tests/baselines/reference/noCatchBlock.js.map b/tests/baselines/reference/noCatchBlock.js.map index 392ec58810852..9e3da66cb317f 100644 --- a/tests/baselines/reference/noCatchBlock.js.map +++ b/tests/baselines/reference/noCatchBlock.js.map @@ -1,2 +1,2 @@ //// [noCatchBlock.js.map] -{"version":3,"file":"noCatchBlock.js","sourceRoot":"","sources":["noCatchBlock.ts"],"names":[],"mappings":"AACA,IAAI,CAAC;IACJ,MAAM;AACP,CAAC;QAAS,CAAC;IACV,wBAAwB;AACzB,CAAC"} \ No newline at end of file +{"version":3,"file":"noCatchBlock.js","sourceRoot":"","sources":["noCatchBlock.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC;IACJ,MAAM;AACP,CAAC;QAAS,CAAC;IACV,wBAAwB;AACzB,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/noCatchBlock.sourcemap.txt b/tests/baselines/reference/noCatchBlock.sourcemap.txt index 5210f12d734ec..455d0538d65b7 100644 --- a/tests/baselines/reference/noCatchBlock.sourcemap.txt +++ b/tests/baselines/reference/noCatchBlock.sourcemap.txt @@ -13,13 +13,12 @@ sourceFile:noCatchBlock.ts 2 >^^^^ 3 > ^ 4 > ^^^^^^-> -1 > - > +1 > 2 >try 3 > { -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) --- >>> // ... 1->^^^^ @@ -27,8 +26,8 @@ sourceFile:noCatchBlock.ts 1-> > 2 > // ... -1->Emitted(2, 5) Source(3, 2) + SourceIndex(0) -2 >Emitted(2, 11) Source(3, 8) + SourceIndex(0) +1->Emitted(2, 5) Source(2, 2) + SourceIndex(0) +2 >Emitted(2, 11) Source(2, 8) + SourceIndex(0) --- >>>} 1 > @@ -37,8 +36,8 @@ sourceFile:noCatchBlock.ts 1 > > 2 >} -1 >Emitted(3, 1) Source(4, 1) + SourceIndex(0) -2 >Emitted(3, 2) Source(4, 2) + SourceIndex(0) +1 >Emitted(3, 1) Source(3, 1) + SourceIndex(0) +2 >Emitted(3, 2) Source(3, 2) + SourceIndex(0) --- >>>finally { 1->^^^^^^^^ @@ -46,8 +45,8 @@ sourceFile:noCatchBlock.ts 3 > ^^^^^^^^^^^^^^^^^^^^-> 1-> finally 2 > { -1->Emitted(4, 9) Source(4, 11) + SourceIndex(0) -2 >Emitted(4, 10) Source(4, 12) + SourceIndex(0) +1->Emitted(4, 9) Source(3, 11) + SourceIndex(0) +2 >Emitted(4, 10) Source(3, 12) + SourceIndex(0) --- >>> // N.B. No 'catch' block 1->^^^^ @@ -55,8 +54,8 @@ sourceFile:noCatchBlock.ts 1-> > 2 > // N.B. No 'catch' block -1->Emitted(5, 5) Source(5, 2) + SourceIndex(0) -2 >Emitted(5, 29) Source(5, 26) + SourceIndex(0) +1->Emitted(5, 5) Source(4, 2) + SourceIndex(0) +2 >Emitted(5, 29) Source(4, 26) + SourceIndex(0) --- >>>} 1 > @@ -65,7 +64,7 @@ sourceFile:noCatchBlock.ts 1 > > 2 >} -1 >Emitted(6, 1) Source(6, 1) + SourceIndex(0) -2 >Emitted(6, 2) Source(6, 2) + SourceIndex(0) +1 >Emitted(6, 1) Source(5, 1) + SourceIndex(0) +2 >Emitted(6, 2) Source(5, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=noCatchBlock.js.map \ No newline at end of file diff --git a/tests/baselines/reference/noCatchBlock.symbols b/tests/baselines/reference/noCatchBlock.symbols index cf7689660a328..655d90f047be5 100644 --- a/tests/baselines/reference/noCatchBlock.symbols +++ b/tests/baselines/reference/noCatchBlock.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/noCatchBlock.ts === - -No type information for this code.try { +try { No type information for this code. // ... No type information for this code.} finally { No type information for this code. // N.B. No 'catch' block diff --git a/tests/baselines/reference/noCatchBlock.types b/tests/baselines/reference/noCatchBlock.types index cf7689660a328..655d90f047be5 100644 --- a/tests/baselines/reference/noCatchBlock.types +++ b/tests/baselines/reference/noCatchBlock.types @@ -1,6 +1,5 @@ === tests/cases/compiler/noCatchBlock.ts === - -No type information for this code.try { +try { No type information for this code. // ... No type information for this code.} finally { No type information for this code. // N.B. No 'catch' block diff --git a/tests/baselines/reference/noEmitHelpers.js b/tests/baselines/reference/noEmitHelpers.js index 1a9ad2579b9f4..b8dfcf7377e8f 100644 --- a/tests/baselines/reference/noEmitHelpers.js +++ b/tests/baselines/reference/noEmitHelpers.js @@ -1,5 +1,4 @@ //// [noEmitHelpers.ts] - class A { } class B extends A { } diff --git a/tests/baselines/reference/noEmitHelpers.symbols b/tests/baselines/reference/noEmitHelpers.symbols index 654f1a6cad520..cab13146cb277 100644 --- a/tests/baselines/reference/noEmitHelpers.symbols +++ b/tests/baselines/reference/noEmitHelpers.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/noEmitHelpers.ts === - class A { } >A : Symbol(A, Decl(noEmitHelpers.ts, 0, 0)) class B extends A { } ->B : Symbol(B, Decl(noEmitHelpers.ts, 1, 11)) +>B : Symbol(B, Decl(noEmitHelpers.ts, 0, 11)) >A : Symbol(A, Decl(noEmitHelpers.ts, 0, 0)) diff --git a/tests/baselines/reference/noEmitHelpers.types b/tests/baselines/reference/noEmitHelpers.types index 01c5d5acb3dc9..d39497d19835f 100644 --- a/tests/baselines/reference/noEmitHelpers.types +++ b/tests/baselines/reference/noEmitHelpers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noEmitHelpers.ts === - class A { } >A : A diff --git a/tests/baselines/reference/noEmitHelpers2.js b/tests/baselines/reference/noEmitHelpers2.js index 64acadf07e348..44ab7900005cf 100644 --- a/tests/baselines/reference/noEmitHelpers2.js +++ b/tests/baselines/reference/noEmitHelpers2.js @@ -1,5 +1,4 @@ //// [noEmitHelpers2.ts] - declare var decorator: any; @decorator diff --git a/tests/baselines/reference/noEmitHelpers2.symbols b/tests/baselines/reference/noEmitHelpers2.symbols index 044026a3db7bc..366a282815145 100644 --- a/tests/baselines/reference/noEmitHelpers2.symbols +++ b/tests/baselines/reference/noEmitHelpers2.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/noEmitHelpers2.ts === - declare var decorator: any; ->decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 1, 11)) +>decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 0, 11)) @decorator ->decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 1, 11)) +>decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 0, 11)) class A { ->A : Symbol(A, Decl(noEmitHelpers2.ts, 1, 27)) +>A : Symbol(A, Decl(noEmitHelpers2.ts, 0, 27)) constructor(a: number, @decorator b: string) { ->a : Symbol(a, Decl(noEmitHelpers2.ts, 5, 16)) ->decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 1, 11)) ->b : Symbol(b, Decl(noEmitHelpers2.ts, 5, 26)) +>a : Symbol(a, Decl(noEmitHelpers2.ts, 4, 16)) +>decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 0, 11)) +>b : Symbol(b, Decl(noEmitHelpers2.ts, 4, 26)) } } diff --git a/tests/baselines/reference/noEmitHelpers2.types b/tests/baselines/reference/noEmitHelpers2.types index 14260e4f95c68..9f2adc8132757 100644 --- a/tests/baselines/reference/noEmitHelpers2.types +++ b/tests/baselines/reference/noEmitHelpers2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noEmitHelpers2.ts === - declare var decorator: any; >decorator : any diff --git a/tests/baselines/reference/noEmitOnError.errors.txt b/tests/baselines/reference/noEmitOnError.errors.txt index 87a71c3075667..6262fa760f016 100644 --- a/tests/baselines/reference/noEmitOnError.errors.txt +++ b/tests/baselines/reference/noEmitOnError.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/noEmitOnError.ts(2,5): error TS2322: Type '""' is not assignable to type 'number'. +tests/cases/compiler/noEmitOnError.ts(1,5): error TS2322: Type '""' is not assignable to type 'number'. ==== tests/cases/compiler/noEmitOnError.ts (1 errors) ==== - var x: number = ""; ~ !!! error TS2322: Type '""' is not assignable to type 'number'. diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.symbols b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.symbols index d3d338e0d14d7..d3d9ab83ea80d 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.symbols +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/0.d.ts === - export = a; ->a : Symbol(a, Decl(0.d.ts, 2, 11)) +>a : Symbol(a, Decl(0.d.ts, 1, 11)) declare var a: number; ->a : Symbol(a, Decl(0.d.ts, 2, 11)) +>a : Symbol(a, Decl(0.d.ts, 1, 11)) diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.types b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.types index c5e2c0b80f889..37092f98088d9 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.types +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/0.d.ts === - export = a; >a : number diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.errors.txt b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.errors.txt index bcf5d91c01510..b9130255e133e 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.errors.txt +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/1.ts(2,1): error TS1148: Cannot use imports, exports, or module augmentations when '--module' is 'none'. +tests/cases/compiler/1.ts(1,1): error TS1148: Cannot use imports, exports, or module augmentations when '--module' is 'none'. ==== tests/cases/compiler/1.ts (1 errors) ==== - export var j = "hello"; // error ~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS1148: Cannot use imports, exports, or module augmentations when '--module' is 'none'. diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.js b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.js index 1e2231868a8f6..fc778fbda09c7 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.js +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.ts] //// //// [1.ts] - export var j = "hello"; // error //// [0.d.ts] diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.errors.txt b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.errors.txt index eb215693cd756..85ad46de437ca 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.errors.txt +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/1.ts(1,1): error TS1148: Cannot use imports, exports, or mo ==== tests/cases/compiler/0.d.ts (0 errors) ==== - export = a; declare var a: number; diff --git a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.js b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.js index f651d4f5b18f5..b97e6e306d7b8 100644 --- a/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.js +++ b/tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.ts] //// //// [0.d.ts] - export = a; declare var a: number; diff --git a/tests/baselines/reference/noImplicitAnyForIn.errors.txt b/tests/baselines/reference/noImplicitAnyForIn.errors.txt index 3db1c260d517c..b384735d82e97 100644 --- a/tests/baselines/reference/noImplicitAnyForIn.errors.txt +++ b/tests/baselines/reference/noImplicitAnyForIn.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/noImplicitAnyForIn.ts(8,18): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. -tests/cases/compiler/noImplicitAnyForIn.ts(15,18): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. -tests/cases/compiler/noImplicitAnyForIn.ts(29,5): error TS7005: Variable 'n' implicitly has an 'any[][]' type. -tests/cases/compiler/noImplicitAnyForIn.ts(31,6): error TS2405: The left-hand side of a 'for...in' statement must be of type 'string' or 'any'. +tests/cases/compiler/noImplicitAnyForIn.ts(7,18): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyForIn.ts(14,18): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyForIn.ts(28,5): error TS7005: Variable 'n' implicitly has an 'any[][]' type. +tests/cases/compiler/noImplicitAnyForIn.ts(30,6): error TS2405: The left-hand side of a 'for...in' statement must be of type 'string' or 'any'. ==== tests/cases/compiler/noImplicitAnyForIn.ts (4 errors) ==== - var x: {}[] = [[1, 2, 3], ["hello"]]; for (var i in x) { diff --git a/tests/baselines/reference/noImplicitAnyForIn.js b/tests/baselines/reference/noImplicitAnyForIn.js index c8743936a9a7c..39dbb77e5e7e5 100644 --- a/tests/baselines/reference/noImplicitAnyForIn.js +++ b/tests/baselines/reference/noImplicitAnyForIn.js @@ -1,5 +1,4 @@ //// [noImplicitAnyForIn.ts] - var x: {}[] = [[1, 2, 3], ["hello"]]; for (var i in x) { diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.js b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.js index 568d94c53bae3..ac8e037d1c008 100644 --- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.js +++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.js @@ -1,5 +1,4 @@ //// [noImplicitAnyFunctionExpressionAssignment.ts] - var x: (a: any) => void = function (x: T) { return null; }; diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols index 8e9a331a2058f..6e1bb888b41c5 100644 --- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols +++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols @@ -1,22 +1,21 @@ === tests/cases/compiler/noImplicitAnyFunctionExpressionAssignment.ts === - var x: (a: any) => void = function (x: T) { ->x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 3)) ->a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 8)) ->T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 36)) ->x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 39)) ->T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 36)) +>x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 3)) +>a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 8)) +>T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 36)) +>x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 39)) +>T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 0, 36)) return null; }; var x2: (a: any) => void = function f(x: T) { ->x2 : Symbol(x2, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 3)) ->a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 9)) ->f : Symbol(f, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 26)) ->T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 38)) ->x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 41)) ->T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 38)) +>x2 : Symbol(x2, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 3)) +>a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 9)) +>f : Symbol(f, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 26)) +>T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 38)) +>x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 41)) +>T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 4, 38)) return null; }; diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types index 9d8e216b6565d..18b61aaf8e33b 100644 --- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types +++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitAnyFunctionExpressionAssignment.ts === - var x: (a: any) => void = function (x: T) { >x : (a: any) => void >a : any diff --git a/tests/baselines/reference/noImplicitAnyFunctions.errors.txt b/tests/baselines/reference/noImplicitAnyFunctions.errors.txt index 158690deef079..88185102a4abd 100644 --- a/tests/baselines/reference/noImplicitAnyFunctions.errors.txt +++ b/tests/baselines/reference/noImplicitAnyFunctions.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/noImplicitAnyFunctions.ts(2,18): error TS7010: 'f1', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyFunctions.ts(6,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyFunctions.ts(17,10): error TS7010: 'f6', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyFunctions.ts(19,10): error TS7010: 'f6', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyFunctions.ts(19,24): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyFunctions.ts(1,18): error TS7010: 'f1', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyFunctions.ts(5,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyFunctions.ts(16,10): error TS7010: 'f6', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyFunctions.ts(18,10): error TS7010: 'f6', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyFunctions.ts(18,24): error TS7006: Parameter 'y' implicitly has an 'any' type. ==== tests/cases/compiler/noImplicitAnyFunctions.ts (5 errors) ==== - declare function f1(); ~~ !!! error TS7010: 'f1', which lacks return-type annotation, implicitly has an 'any' return type. diff --git a/tests/baselines/reference/noImplicitAnyFunctions.js b/tests/baselines/reference/noImplicitAnyFunctions.js index 57998188d9e4a..369a6f71044b8 100644 --- a/tests/baselines/reference/noImplicitAnyFunctions.js +++ b/tests/baselines/reference/noImplicitAnyFunctions.js @@ -1,5 +1,4 @@ //// [noImplicitAnyFunctions.ts] - declare function f1(); declare function f2(): any; diff --git a/tests/baselines/reference/noImplicitAnyInBareInterface.errors.txt b/tests/baselines/reference/noImplicitAnyInBareInterface.errors.txt index eb379c6702668..01c8e4ee6c553 100644 --- a/tests/baselines/reference/noImplicitAnyInBareInterface.errors.txt +++ b/tests/baselines/reference/noImplicitAnyInBareInterface.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/noImplicitAnyInBareInterface.ts(4,5): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyInBareInterface.ts(6,5): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyInBareInterface.ts(3,5): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyInBareInterface.ts(5,5): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. ==== tests/cases/compiler/noImplicitAnyInBareInterface.ts (2 errors) ==== - interface Entry { // Should return error for implicit any on `new` and `foo`. new (); diff --git a/tests/baselines/reference/noImplicitAnyInBareInterface.js b/tests/baselines/reference/noImplicitAnyInBareInterface.js index 0a3bbe1bb8ec4..817e137ce0913 100644 --- a/tests/baselines/reference/noImplicitAnyInBareInterface.js +++ b/tests/baselines/reference/noImplicitAnyInBareInterface.js @@ -1,5 +1,4 @@ //// [noImplicitAnyInBareInterface.ts] - interface Entry { // Should return error for implicit any on `new` and `foo`. new (); diff --git a/tests/baselines/reference/noImplicitAnyInCastExpression.errors.txt b/tests/baselines/reference/noImplicitAnyInCastExpression.errors.txt index 8243a9c68ce8d..769353b996582 100644 --- a/tests/baselines/reference/noImplicitAnyInCastExpression.errors.txt +++ b/tests/baselines/reference/noImplicitAnyInCastExpression.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/noImplicitAnyInCastExpression.ts(16,2): error TS2352: Type '{ c: null; }' cannot be converted to type 'IFoo'. +tests/cases/compiler/noImplicitAnyInCastExpression.ts(15,2): error TS2352: Type '{ c: null; }' cannot be converted to type 'IFoo'. Property 'a' is missing in type '{ c: null; }'. ==== tests/cases/compiler/noImplicitAnyInCastExpression.ts (1 errors) ==== - // verify no noImplictAny errors reported with cast expression interface IFoo { diff --git a/tests/baselines/reference/noImplicitAnyInCastExpression.js b/tests/baselines/reference/noImplicitAnyInCastExpression.js index b0a6907a5b485..cb84e3f770106 100644 --- a/tests/baselines/reference/noImplicitAnyInCastExpression.js +++ b/tests/baselines/reference/noImplicitAnyInCastExpression.js @@ -1,5 +1,4 @@ //// [noImplicitAnyInCastExpression.ts] - // verify no noImplictAny errors reported with cast expression interface IFoo { diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.js b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.js index 7722165fd231a..e6a3d084ea5ea 100644 --- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.js +++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.js @@ -1,5 +1,4 @@ //// [noImplicitAnyInContextuallyTypesFunctionParamter.ts] - var regexMatchList = ['', '']; regexMatchList.forEach(match => ''.replace(match, '')); diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols index 45b62e29b8a97..d76ee3019b337 100644 --- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols +++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/noImplicitAnyInContextuallyTypesFunctionParamter.ts === - var regexMatchList = ['', '']; ->regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3)) +>regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 0, 3)) regexMatchList.forEach(match => ''.replace(match, '')); >regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3)) +>regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 0, 3)) >forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23)) +>match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 23)) >''.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23)) +>match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 23)) diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types index 100d64482cefe..700a88a1dabee 100644 --- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types +++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitAnyInContextuallyTypesFunctionParamter.ts === - var regexMatchList = ['', '']; >regexMatchList : string[] >['', ''] : string[] diff --git a/tests/baselines/reference/noImplicitAnyIndexing.errors.txt b/tests/baselines/reference/noImplicitAnyIndexing.errors.txt index 3274bec5aae49..8d1d3ea6c467d 100644 --- a/tests/baselines/reference/noImplicitAnyIndexing.errors.txt +++ b/tests/baselines/reference/noImplicitAnyIndexing.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/noImplicitAnyIndexing.ts(13,37): error TS7015: Element implicitly has an 'any' type because index expression is not of type 'number'. -tests/cases/compiler/noImplicitAnyIndexing.ts(20,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. -tests/cases/compiler/noImplicitAnyIndexing.ts(23,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. -tests/cases/compiler/noImplicitAnyIndexing.ts(31,10): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyIndexing.ts(12,37): error TS7015: Element implicitly has an 'any' type because index expression is not of type 'number'. +tests/cases/compiler/noImplicitAnyIndexing.ts(19,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyIndexing.ts(22,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyIndexing.ts(30,10): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. ==== tests/cases/compiler/noImplicitAnyIndexing.ts (4 errors) ==== - enum MyEmusEnum { emu } diff --git a/tests/baselines/reference/noImplicitAnyIndexing.js b/tests/baselines/reference/noImplicitAnyIndexing.js index 8451a1426a609..2fe60873e6128 100644 --- a/tests/baselines/reference/noImplicitAnyIndexing.js +++ b/tests/baselines/reference/noImplicitAnyIndexing.js @@ -1,5 +1,4 @@ //// [noImplicitAnyIndexing.ts] - enum MyEmusEnum { emu } diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js index 6d91d8eb83888..7d871d8321746 100644 --- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js +++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js @@ -1,5 +1,4 @@ //// [noImplicitAnyIndexingSuppressed.ts] - enum MyEmusEnum { emu } diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols index 96b3840856062..d97a59cf091c9 100644 --- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols +++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols @@ -1,74 +1,73 @@ === tests/cases/compiler/noImplicitAnyIndexingSuppressed.ts === - enum MyEmusEnum { >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) emu ->emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) } // Should be okay; should be a string. var strRepresentation1 = MyEmusEnum[0] ->strRepresentation1 : Symbol(strRepresentation1, Decl(noImplicitAnyIndexingSuppressed.ts, 6, 3)) +>strRepresentation1 : Symbol(strRepresentation1, Decl(noImplicitAnyIndexingSuppressed.ts, 5, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) // Should be okay; should be a string. var strRepresentation2 = MyEmusEnum[MyEmusEnum.emu] ->strRepresentation2 : Symbol(strRepresentation2, Decl(noImplicitAnyIndexingSuppressed.ts, 9, 3)) +>strRepresentation2 : Symbol(strRepresentation2, Decl(noImplicitAnyIndexingSuppressed.ts, 8, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) // Should be okay, as we suppress implicit 'any' property access checks var strRepresentation3 = MyEmusEnum["monehh"]; ->strRepresentation3 : Symbol(strRepresentation3, Decl(noImplicitAnyIndexingSuppressed.ts, 12, 3)) +>strRepresentation3 : Symbol(strRepresentation3, Decl(noImplicitAnyIndexingSuppressed.ts, 11, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) // Should be okay; should be a MyEmusEnum var strRepresentation4 = MyEmusEnum["emu"]; ->strRepresentation4 : Symbol(strRepresentation4, Decl(noImplicitAnyIndexingSuppressed.ts, 15, 3)) +>strRepresentation4 : Symbol(strRepresentation4, Decl(noImplicitAnyIndexingSuppressed.ts, 14, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->"emu" : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>"emu" : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) // Should be okay, as we suppress implicit 'any' property access checks var x = {}["hi"]; ->x : Symbol(x, Decl(noImplicitAnyIndexingSuppressed.ts, 19, 3)) +>x : Symbol(x, Decl(noImplicitAnyIndexingSuppressed.ts, 18, 3)) // Should be okay, as we suppress implicit 'any' property access checks var y = {}[10]; ->y : Symbol(y, Decl(noImplicitAnyIndexingSuppressed.ts, 22, 3)) +>y : Symbol(y, Decl(noImplicitAnyIndexingSuppressed.ts, 21, 3)) var hi: any = "hi"; ->hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3)) +>hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 23, 3)) var emptyObj = {}; ->emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 3)) +>emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 25, 3)) // Should be okay, as we suppress implicit 'any' property access checks var z1 = emptyObj[hi]; ->z1 : Symbol(z1, Decl(noImplicitAnyIndexingSuppressed.ts, 29, 3)) ->emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 3)) ->hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3)) +>z1 : Symbol(z1, Decl(noImplicitAnyIndexingSuppressed.ts, 28, 3)) +>emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 25, 3)) +>hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 23, 3)) var z2 = (emptyObj)[hi]; ->z2 : Symbol(z2, Decl(noImplicitAnyIndexingSuppressed.ts, 30, 3)) ->emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 3)) ->hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3)) +>z2 : Symbol(z2, Decl(noImplicitAnyIndexingSuppressed.ts, 29, 3)) +>emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 25, 3)) +>hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 23, 3)) interface MyMap { ->MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 30, 29)) ->T : Symbol(T, Decl(noImplicitAnyIndexingSuppressed.ts, 32, 16)) +>MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 29, 29)) +>T : Symbol(T, Decl(noImplicitAnyIndexingSuppressed.ts, 31, 16)) [key: string]: T; ->key : Symbol(key, Decl(noImplicitAnyIndexingSuppressed.ts, 33, 5)) ->T : Symbol(T, Decl(noImplicitAnyIndexingSuppressed.ts, 32, 16)) +>key : Symbol(key, Decl(noImplicitAnyIndexingSuppressed.ts, 32, 5)) +>T : Symbol(T, Decl(noImplicitAnyIndexingSuppressed.ts, 31, 16)) } var m: MyMap = { ->m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3)) ->MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 30, 29)) +>m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 35, 3)) +>MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 29, 29)) "0": 0, "1": 1, @@ -79,23 +78,23 @@ var m: MyMap = { }; var mResult1 = m[MyEmusEnum.emu]; ->mResult1 : Symbol(mResult1, Decl(noImplicitAnyIndexingSuppressed.ts, 43, 3)) ->m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3)) ->MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>mResult1 : Symbol(mResult1, Decl(noImplicitAnyIndexingSuppressed.ts, 42, 3)) +>m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 35, 3)) +>MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) var mResult2 = m[MyEmusEnum[MyEmusEnum.emu]]; ->mResult2 : Symbol(mResult2, Decl(noImplicitAnyIndexingSuppressed.ts, 44, 3)) ->m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3)) +>mResult2 : Symbol(mResult2, Decl(noImplicitAnyIndexingSuppressed.ts, 43, 3)) +>m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 35, 3)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>MyEmusEnum.emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) >MyEmusEnum : Symbol(MyEmusEnum, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 0)) ->emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 1, 17)) +>emu : Symbol(MyEmusEnum.emu, Decl(noImplicitAnyIndexingSuppressed.ts, 0, 17)) var mResult3 = m[hi]; ->mResult3 : Symbol(mResult3, Decl(noImplicitAnyIndexingSuppressed.ts, 45, 3)) ->m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3)) ->hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3)) +>mResult3 : Symbol(mResult3, Decl(noImplicitAnyIndexingSuppressed.ts, 44, 3)) +>m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 35, 3)) +>hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 23, 3)) diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types index 6bb0c04fbb0f4..18c10871cf039 100644 --- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types +++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitAnyIndexingSuppressed.ts === - enum MyEmusEnum { >MyEmusEnum : MyEmusEnum diff --git a/tests/baselines/reference/noImplicitAnyMissingGetAccessor.errors.txt b/tests/baselines/reference/noImplicitAnyMissingGetAccessor.errors.txt index ef2a273711f21..434058d13a4de 100644 --- a/tests/baselines/reference/noImplicitAnyMissingGetAccessor.errors.txt +++ b/tests/baselines/reference/noImplicitAnyMissingGetAccessor.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(4,25): error TS7032: Property 'message' implicitly has type 'any', because its set accessor lacks a parameter type annotation. -tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(4,33): error TS7006: Parameter 'str' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(9,16): error TS7032: Property 'message' implicitly has type 'any', because its set accessor lacks a parameter type annotation. -tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(9,24): error TS7006: Parameter 'str' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(3,25): error TS7032: Property 'message' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(3,33): error TS7006: Parameter 'str' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(8,16): error TS7032: Property 'message' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts(8,24): error TS7006: Parameter 'str' implicitly has an 'any' type. ==== tests/cases/compiler/noImplicitAnyMissingGetAccessor.ts (4 errors) ==== - abstract class Parent { public abstract set message(str); diff --git a/tests/baselines/reference/noImplicitAnyMissingGetAccessor.js b/tests/baselines/reference/noImplicitAnyMissingGetAccessor.js index 7dc7e4dafb3ab..12b6501e26acc 100644 --- a/tests/baselines/reference/noImplicitAnyMissingGetAccessor.js +++ b/tests/baselines/reference/noImplicitAnyMissingGetAccessor.js @@ -1,5 +1,4 @@ //// [noImplicitAnyMissingGetAccessor.ts] - abstract class Parent { public abstract set message(str); diff --git a/tests/baselines/reference/noImplicitAnyMissingSetAccessor.errors.txt b/tests/baselines/reference/noImplicitAnyMissingSetAccessor.errors.txt index ba104209189f3..4e69b22aab5df 100644 --- a/tests/baselines/reference/noImplicitAnyMissingSetAccessor.errors.txt +++ b/tests/baselines/reference/noImplicitAnyMissingSetAccessor.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/noImplicitAnyMissingSetAccessor.ts(4,25): error TS7033: Property 'message' implicitly has type 'any', because its get accessor lacks a return type annotation. +tests/cases/compiler/noImplicitAnyMissingSetAccessor.ts(3,25): error TS7033: Property 'message' implicitly has type 'any', because its get accessor lacks a return type annotation. ==== tests/cases/compiler/noImplicitAnyMissingSetAccessor.ts (1 errors) ==== - abstract class Parent { public abstract get message(); diff --git a/tests/baselines/reference/noImplicitAnyMissingSetAccessor.js b/tests/baselines/reference/noImplicitAnyMissingSetAccessor.js index 31d7e65ed9b6d..a5ef6bfc1f40a 100644 --- a/tests/baselines/reference/noImplicitAnyMissingSetAccessor.js +++ b/tests/baselines/reference/noImplicitAnyMissingSetAccessor.js @@ -1,5 +1,4 @@ //// [noImplicitAnyMissingSetAccessor.ts] - abstract class Parent { public abstract get message(); diff --git a/tests/baselines/reference/noImplicitAnyModule.errors.txt b/tests/baselines/reference/noImplicitAnyModule.errors.txt index 35c0993df3e2a..131486655d631 100644 --- a/tests/baselines/reference/noImplicitAnyModule.errors.txt +++ b/tests/baselines/reference/noImplicitAnyModule.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/noImplicitAnyModule.ts(5,9): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyModule.ts(10,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyModule.ts(11,16): error TS7010: 'g', which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyModule.ts(18,14): error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyModule.ts(4,9): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyModule.ts(9,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyModule.ts(10,16): error TS7010: 'g', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyModule.ts(17,14): error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type. ==== tests/cases/compiler/noImplicitAnyModule.ts (4 errors) ==== - declare module Module { interface Interface { // Should return error for implicit any on return type. diff --git a/tests/baselines/reference/noImplicitAnyModule.js b/tests/baselines/reference/noImplicitAnyModule.js index 9ce7309e370b7..7d490b8b3c752 100644 --- a/tests/baselines/reference/noImplicitAnyModule.js +++ b/tests/baselines/reference/noImplicitAnyModule.js @@ -1,5 +1,4 @@ //// [noImplicitAnyModule.ts] - declare module Module { interface Interface { // Should return error for implicit any on return type. diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.errors.txt index a2ac9467856dd..0d308e92557fe 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.errors.txt @@ -1,38 +1,37 @@ -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(7,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(13,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(13,22): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(13,25): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(16,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(16,30): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(19,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(22,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(22,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(25,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(26,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(27,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(27,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(33,22): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(36,22): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(36,25): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(36,28): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(39,22): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(39,33): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(42,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(45,22): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(45,25): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(79,24): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(82,24): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(82,27): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(82,30): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(85,24): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(85,35): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(88,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(91,24): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(91,27): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(6,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(12,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(12,22): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(12,25): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(15,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(15,30): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(18,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(21,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(21,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(24,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(25,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(26,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(26,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(32,22): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(35,22): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(35,25): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(35,28): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(38,22): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(38,33): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(41,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(44,22): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(44,25): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(78,24): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(81,24): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(81,27): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(81,30): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(84,24): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(84,35): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(87,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(90,24): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts(90,27): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInAmbientClass.ts (31 errors) ==== - declare class D_C { // No implicit-'any' errors. public pub_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.js b/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.js index 4af0a8c74a3e2..9e92ac9ecc538 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.js +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientClass.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInAmbientClass.ts] - declare class D_C { // No implicit-'any' errors. public pub_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.errors.txt index 37af83d7891cf..fd9b3ac4053d7 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(6,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(12,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(12,26): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(12,29): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(15,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(15,34): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(18,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(21,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(21,26): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(24,23): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(25,35): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(26,23): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(26,27): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(32,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(35,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(35,24): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(35,27): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(38,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(38,32): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(41,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(44,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(44,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(5,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(11,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(11,26): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(11,29): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(14,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(14,34): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(17,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(20,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(20,26): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(23,23): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(24,35): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(25,23): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(25,27): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(31,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(34,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(34,24): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(34,27): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(37,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(37,32): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(40,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(43,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts(43,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInAmbientFunctions.ts (22 errors) ==== - // No implicit-'any' errors. declare function d_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.js b/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.js index 3e825c2b24fc2..aa8f2bd8bb39f 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.js +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInAmbientFunctions.ts] - // No implicit-'any' errors. declare function d_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.errors.txt index 7bdfbcaae8803..04720e3a8b9f9 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(7,20): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(13,20): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(13,23): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(13,26): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(16,20): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(16,31): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(19,20): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(22,20): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(22,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(25,20): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(26,32): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(27,20): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(27,24): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(33,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(36,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(36,21): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(36,24): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(39,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(39,29): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(42,18): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(45,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(45,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(6,20): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(12,20): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(12,23): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(12,26): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(15,20): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(15,31): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(18,20): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(21,20): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(21,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(24,20): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(25,32): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(26,20): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(26,24): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(32,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(35,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(35,21): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(35,24): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(38,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(38,29): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(41,18): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(44,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts(44,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInAmbientModule.ts (22 errors) ==== - declare module D_M { // No implicit-'any' errors. function dm_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.js b/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.js index d35cbe9d9d48f..51788b62dc162 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.js +++ b/tests/baselines/reference/noImplicitAnyParametersInAmbientModule.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInAmbientModule.ts] - declare module D_M { // No implicit-'any' errors. function dm_f1(): void; diff --git a/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.errors.txt index 3d3cc1aa5eaac..859f50708ea81 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(6,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(12,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(12,16): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(12,19): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(15,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(15,24): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(18,13): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(21,13): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(21,16): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(24,13): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(25,25): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(26,13): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(26,17): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(32,12): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(35,12): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(35,15): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(35,18): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(38,12): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(38,23): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(41,12): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(44,12): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(44,15): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(5,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(11,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(11,16): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(11,19): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(14,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(14,24): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(17,13): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(20,13): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(20,16): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(23,13): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(24,25): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(25,13): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(25,17): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(31,12): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(34,12): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(34,15): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(34,18): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(37,12): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(37,23): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(40,12): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(43,12): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts(43,15): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInBareFunctions.ts (22 errors) ==== - // No implicit-'any' errors. function f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.js b/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.js index 3b0b630b537c4..4371a60879930 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.js +++ b/tests/baselines/reference/noImplicitAnyParametersInBareFunctions.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInBareFunctions.ts] - // No implicit-'any' errors. function f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInClass.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInClass.errors.txt index 98d743a21aa8c..2e9041f5c5101 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInClass.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInClass.errors.txt @@ -1,51 +1,50 @@ -tests/cases/compiler/noImplicitAnyParametersInClass.ts(7,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(13,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(13,22): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(13,25): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(16,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(16,30): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(19,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(22,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(22,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(25,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(26,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(27,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(27,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(33,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(36,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(36,26): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(36,29): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(39,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(39,34): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(42,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(45,23): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(45,26): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(53,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(59,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(59,24): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(59,27): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(62,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(62,32): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(65,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(68,21): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(68,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(71,21): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(72,33): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(73,21): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(73,25): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(79,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(82,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(82,28): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(82,31): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(85,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(85,36): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(88,25): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(91,25): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInClass.ts(91,28): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(6,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(12,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(12,22): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(12,25): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(15,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(15,30): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(18,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(21,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(21,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(24,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(25,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(26,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(26,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(32,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(35,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(35,26): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(35,29): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(38,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(38,34): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(41,23): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(44,23): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(44,26): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(52,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(58,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(58,24): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(58,27): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(61,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(61,32): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(64,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(67,21): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(67,24): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(70,21): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(71,33): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(72,21): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(72,25): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(78,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(81,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(81,28): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(81,31): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(84,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(84,36): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(87,25): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(90,25): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInClass.ts(90,28): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInClass.ts (44 errors) ==== - class C { // No implicit-'any' errors. public pub_f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInClass.js b/tests/baselines/reference/noImplicitAnyParametersInClass.js index 4ad093f56be8b..648f93dccdc28 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInClass.js +++ b/tests/baselines/reference/noImplicitAnyParametersInClass.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInClass.ts] - class C { // No implicit-'any' errors. public pub_f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInInterface.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInInterface.errors.txt index f0b9fad3b33a4..a001a857b4ef4 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInInterface.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInInterface.errors.txt @@ -1,34 +1,33 @@ +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(3,5): error TS7020: Call signature, which lacks return-type annotation, implicitly has an 'any' return type. tests/cases/compiler/noImplicitAnyParametersInInterface.ts(4,5): error TS7020: Call signature, which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(5,5): error TS7020: Call signature, which lacks return-type annotation, implicitly has an 'any' return type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(5,6): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(6,6): error TS7006: Parameter 'x2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(6,22): error TS7006: Parameter 'z2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(12,8): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(18,8): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(18,11): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(18,14): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(21,8): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(21,19): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(24,8): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(27,8): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(27,11): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(30,8): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(31,20): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(32,8): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(32,12): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(38,11): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(41,11): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(41,14): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(41,17): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(44,11): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(44,22): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(47,11): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(50,11): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInInterface.ts(50,14): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(4,6): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(5,6): error TS7006: Parameter 'x2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(5,22): error TS7006: Parameter 'z2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(11,8): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(17,8): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(17,11): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(17,14): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(20,8): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(20,19): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(23,8): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(26,8): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(26,11): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(29,8): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(30,20): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(31,8): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(31,12): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(37,11): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(40,11): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(40,14): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(40,17): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(43,11): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(43,22): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(46,11): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(49,11): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInInterface.ts(49,14): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInInterface.ts (27 errors) ==== - interface I { // Implicit-'any' errors for first two call signatures, x1, x2, z2. (); diff --git a/tests/baselines/reference/noImplicitAnyParametersInInterface.js b/tests/baselines/reference/noImplicitAnyParametersInInterface.js index e8844fa1fad72..59afde51a1ba9 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInInterface.js +++ b/tests/baselines/reference/noImplicitAnyParametersInInterface.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInInterface.ts] - interface I { // Implicit-'any' errors for first two call signatures, x1, x2, z2. (); diff --git a/tests/baselines/reference/noImplicitAnyParametersInModule.errors.txt b/tests/baselines/reference/noImplicitAnyParametersInModule.errors.txt index 8bddee624c561..85ca9d933d3a4 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInModule.errors.txt +++ b/tests/baselines/reference/noImplicitAnyParametersInModule.errors.txt @@ -1,29 +1,28 @@ -tests/cases/compiler/noImplicitAnyParametersInModule.ts(7,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(13,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(13,22): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(13,25): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(16,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(16,30): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(19,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(22,19): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(22,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(25,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(26,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(27,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(27,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(33,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(36,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(36,21): error TS7006: Parameter 'y' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(36,24): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(39,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(39,29): error TS7006: Parameter 'z' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(42,18): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(45,18): error TS7006: Parameter 'x' implicitly has an 'any' type. -tests/cases/compiler/noImplicitAnyParametersInModule.ts(45,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(6,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(12,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(12,22): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(12,25): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(15,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(15,30): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(18,19): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(21,19): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(21,22): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(24,19): error TS7006: Parameter 'x1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(25,31): error TS7006: Parameter 'y2' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(26,19): error TS7006: Parameter 'x3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(26,23): error TS7006: Parameter 'y3' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(32,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(35,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(35,21): error TS7006: Parameter 'y' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(35,24): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(38,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(38,29): error TS7006: Parameter 'z' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(41,18): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(44,18): error TS7006: Parameter 'x' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyParametersInModule.ts(44,21): error TS7019: Rest parameter 'r' implicitly has an 'any[]' type. ==== tests/cases/compiler/noImplicitAnyParametersInModule.ts (22 errors) ==== - module M { // No implicit-'any' errors. function m_f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyParametersInModule.js b/tests/baselines/reference/noImplicitAnyParametersInModule.js index 1866696fe34d1..d34f52eaa4f19 100644 --- a/tests/baselines/reference/noImplicitAnyParametersInModule.js +++ b/tests/baselines/reference/noImplicitAnyParametersInModule.js @@ -1,5 +1,4 @@ //// [noImplicitAnyParametersInModule.ts] - module M { // No implicit-'any' errors. function m_f1(): void { } diff --git a/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.errors.txt b/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.errors.txt index d782e05ca61c1..c3fa4eebdbae1 100644 --- a/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.errors.txt +++ b/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/noImplicitAnyReferencingDeclaredInterface.ts(4,5): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/compiler/noImplicitAnyReferencingDeclaredInterface.ts(3,5): error TS7013: Construct signature, which lacks return-type annotation, implicitly has an 'any' return type. ==== tests/cases/compiler/noImplicitAnyReferencingDeclaredInterface.ts (1 errors) ==== - interface Entry { // Should return error for implicit any. new (); diff --git a/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.js b/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.js index d688e84911c79..55d13f1337dca 100644 --- a/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.js +++ b/tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.js @@ -1,5 +1,4 @@ //// [noImplicitAnyReferencingDeclaredInterface.ts] - interface Entry { // Should return error for implicit any. new (); diff --git a/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.errors.txt b/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.errors.txt index c66a0a831082c..8a068048f3b12 100644 --- a/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.errors.txt +++ b/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/noImplicitAnyStringIndexerOnObject.ts(2,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. +tests/cases/compiler/noImplicitAnyStringIndexerOnObject.ts(1,9): error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. ==== tests/cases/compiler/noImplicitAnyStringIndexerOnObject.ts (1 errors) ==== - var x = {}["hello"]; ~~~~~~~~~~~ !!! error TS7017: Element implicitly has an 'any' type because type '{}' has no index signature. \ No newline at end of file diff --git a/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.js b/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.js index ab9ab1752a1f2..cc2309192e1a2 100644 --- a/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.js +++ b/tests/baselines/reference/noImplicitAnyStringIndexerOnObject.js @@ -1,5 +1,4 @@ //// [noImplicitAnyStringIndexerOnObject.ts] - var x = {}["hello"]; //// [noImplicitAnyStringIndexerOnObject.js] diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.js b/tests/baselines/reference/noImplicitReturnsInAsync1.js index 5ab86a91d3bbf..e165cafe3b1bb 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync1.js +++ b/tests/baselines/reference/noImplicitReturnsInAsync1.js @@ -1,5 +1,4 @@ //// [noImplicitReturnsInAsync1.ts] - async function test(isError: boolean = false) { if (isError === true) { return; diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols index 58d14c2a6d04e..3d8a37ff08049 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols +++ b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/noImplicitReturnsInAsync1.ts === - async function test(isError: boolean = false) { >test : Symbol(test, Decl(noImplicitReturnsInAsync1.ts, 0, 0)) ->isError : Symbol(isError, Decl(noImplicitReturnsInAsync1.ts, 1, 20)) +>isError : Symbol(isError, Decl(noImplicitReturnsInAsync1.ts, 0, 20)) if (isError === true) { ->isError : Symbol(isError, Decl(noImplicitReturnsInAsync1.ts, 1, 20)) +>isError : Symbol(isError, Decl(noImplicitReturnsInAsync1.ts, 0, 20)) return; } let x = await Promise.resolve("The test is passed without an error."); ->x : Symbol(x, Decl(noImplicitReturnsInAsync1.ts, 5, 7)) +>x : Symbol(x, Decl(noImplicitReturnsInAsync1.ts, 4, 7)) >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.types b/tests/baselines/reference/noImplicitReturnsInAsync1.types index 19da8fdfaf4a3..dd468d33e6e21 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync1.types +++ b/tests/baselines/reference/noImplicitReturnsInAsync1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitReturnsInAsync1.ts === - async function test(isError: boolean = false) { >test : (isError?: boolean) => Promise >isError : boolean diff --git a/tests/baselines/reference/noImplicitReturnsInAsync2.errors.txt b/tests/baselines/reference/noImplicitReturnsInAsync2.errors.txt index 83673ff518bfd..b8e4951e18504 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync2.errors.txt +++ b/tests/baselines/reference/noImplicitReturnsInAsync2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/noImplicitReturnsInAsync2.ts(3,16): error TS7030: Not all code paths return a value. -tests/cases/compiler/noImplicitReturnsInAsync2.ts(25,48): error TS7030: Not all code paths return a value. +tests/cases/compiler/noImplicitReturnsInAsync2.ts(2,16): error TS7030: Not all code paths return a value. +tests/cases/compiler/noImplicitReturnsInAsync2.ts(24,48): error TS7030: Not all code paths return a value. ==== tests/cases/compiler/noImplicitReturnsInAsync2.ts (2 errors) ==== - // Should be an error, Promise, currently retorted correctly async function test3(isError: boolean = true) { ~~~~~ diff --git a/tests/baselines/reference/noImplicitReturnsInAsync2.js b/tests/baselines/reference/noImplicitReturnsInAsync2.js index 7e7f22bd69185..e84b42e8a555c 100644 --- a/tests/baselines/reference/noImplicitReturnsInAsync2.js +++ b/tests/baselines/reference/noImplicitReturnsInAsync2.js @@ -1,5 +1,4 @@ //// [noImplicitReturnsInAsync2.ts] - // Should be an error, Promise, currently retorted correctly async function test3(isError: boolean = true) { if (isError === true) { diff --git a/tests/baselines/reference/noImplicitThisFunctions.errors.txt b/tests/baselines/reference/noImplicitThisFunctions.errors.txt index 5f66ac3553fac..782b752d9e478 100644 --- a/tests/baselines/reference/noImplicitThisFunctions.errors.txt +++ b/tests/baselines/reference/noImplicitThisFunctions.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/noImplicitThisFunctions.ts(14,12): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. -tests/cases/compiler/noImplicitThisFunctions.ts(18,38): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. +tests/cases/compiler/noImplicitThisFunctions.ts(13,12): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. +tests/cases/compiler/noImplicitThisFunctions.ts(17,38): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. ==== tests/cases/compiler/noImplicitThisFunctions.ts (2 errors) ==== - function f1(x) { // implicit any is still allowed return x + 1; diff --git a/tests/baselines/reference/noImplicitThisFunctions.js b/tests/baselines/reference/noImplicitThisFunctions.js index 80ceccbe75176..c54a9cfaa8a70 100644 --- a/tests/baselines/reference/noImplicitThisFunctions.js +++ b/tests/baselines/reference/noImplicitThisFunctions.js @@ -1,5 +1,4 @@ //// [noImplicitThisFunctions.ts] - function f1(x) { // implicit any is still allowed return x + 1; diff --git a/tests/baselines/reference/noImplicitUseStrict_amd.js b/tests/baselines/reference/noImplicitUseStrict_amd.js index 387d5b9497b33..b91eb949ef186 100644 --- a/tests/baselines/reference/noImplicitUseStrict_amd.js +++ b/tests/baselines/reference/noImplicitUseStrict_amd.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_amd.ts] - export var x = 0; //// [noImplicitUseStrict_amd.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_amd.symbols b/tests/baselines/reference/noImplicitUseStrict_amd.symbols index de1faa2213c0d..fb9e6252cebbc 100644 --- a/tests/baselines/reference/noImplicitUseStrict_amd.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_amd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_amd.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_amd.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_amd.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_amd.types b/tests/baselines/reference/noImplicitUseStrict_amd.types index 5eec5bf57af18..a63644347b7a0 100644 --- a/tests/baselines/reference/noImplicitUseStrict_amd.types +++ b/tests/baselines/reference/noImplicitUseStrict_amd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_amd.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noImplicitUseStrict_commonjs.js b/tests/baselines/reference/noImplicitUseStrict_commonjs.js index 4b6fd2db6cd61..842eae22229c5 100644 --- a/tests/baselines/reference/noImplicitUseStrict_commonjs.js +++ b/tests/baselines/reference/noImplicitUseStrict_commonjs.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_commonjs.ts] - export var x = 0; //// [noImplicitUseStrict_commonjs.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_commonjs.symbols b/tests/baselines/reference/noImplicitUseStrict_commonjs.symbols index af53dc272d255..c96a624ba8d95 100644 --- a/tests/baselines/reference/noImplicitUseStrict_commonjs.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_commonjs.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_commonjs.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_commonjs.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_commonjs.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_commonjs.types b/tests/baselines/reference/noImplicitUseStrict_commonjs.types index ad7ed27dfe6db..7f30279b6f545 100644 --- a/tests/baselines/reference/noImplicitUseStrict_commonjs.types +++ b/tests/baselines/reference/noImplicitUseStrict_commonjs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_commonjs.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noImplicitUseStrict_es6.js b/tests/baselines/reference/noImplicitUseStrict_es6.js index 27dbbc7ea7957..badba4adf48c8 100644 --- a/tests/baselines/reference/noImplicitUseStrict_es6.js +++ b/tests/baselines/reference/noImplicitUseStrict_es6.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_es6.ts] - export var x = 0; //// [noImplicitUseStrict_es6.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_es6.symbols b/tests/baselines/reference/noImplicitUseStrict_es6.symbols index 31bc1904ff987..4352ee7fc271f 100644 --- a/tests/baselines/reference/noImplicitUseStrict_es6.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_es6.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_es6.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_es6.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_es6.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_es6.types b/tests/baselines/reference/noImplicitUseStrict_es6.types index 38a83033ff719..d37c2ce67a38a 100644 --- a/tests/baselines/reference/noImplicitUseStrict_es6.types +++ b/tests/baselines/reference/noImplicitUseStrict_es6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_es6.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noImplicitUseStrict_system.js b/tests/baselines/reference/noImplicitUseStrict_system.js index f1100e20fd7ca..a466d9b516334 100644 --- a/tests/baselines/reference/noImplicitUseStrict_system.js +++ b/tests/baselines/reference/noImplicitUseStrict_system.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_system.ts] - export var x = 0; //// [noImplicitUseStrict_system.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_system.symbols b/tests/baselines/reference/noImplicitUseStrict_system.symbols index 62b89a6593da1..f002e9cebdaed 100644 --- a/tests/baselines/reference/noImplicitUseStrict_system.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_system.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_system.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_system.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_system.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_system.types b/tests/baselines/reference/noImplicitUseStrict_system.types index 66246719284aa..1916557083162 100644 --- a/tests/baselines/reference/noImplicitUseStrict_system.types +++ b/tests/baselines/reference/noImplicitUseStrict_system.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_system.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noImplicitUseStrict_umd.js b/tests/baselines/reference/noImplicitUseStrict_umd.js index 484909c51fc84..f53d6098298ee 100644 --- a/tests/baselines/reference/noImplicitUseStrict_umd.js +++ b/tests/baselines/reference/noImplicitUseStrict_umd.js @@ -1,5 +1,4 @@ //// [noImplicitUseStrict_umd.ts] - export var x = 0; //// [noImplicitUseStrict_umd.js] diff --git a/tests/baselines/reference/noImplicitUseStrict_umd.symbols b/tests/baselines/reference/noImplicitUseStrict_umd.symbols index a72a251ad09a5..1b06987a9635f 100644 --- a/tests/baselines/reference/noImplicitUseStrict_umd.symbols +++ b/tests/baselines/reference/noImplicitUseStrict_umd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_umd.ts === - export var x = 0; ->x : Symbol(x, Decl(noImplicitUseStrict_umd.ts, 1, 10)) +>x : Symbol(x, Decl(noImplicitUseStrict_umd.ts, 0, 10)) diff --git a/tests/baselines/reference/noImplicitUseStrict_umd.types b/tests/baselines/reference/noImplicitUseStrict_umd.types index 102f21c238b4b..8e32f24af4ed0 100644 --- a/tests/baselines/reference/noImplicitUseStrict_umd.types +++ b/tests/baselines/reference/noImplicitUseStrict_umd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/noImplicitUseStrict_umd.ts === - export var x = 0; >x : number >0 : 0 diff --git a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols index 690a19ef18f7c..8b1adfe793808 100644 --- a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols +++ b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/test.d.ts === - declare var S: typeof A; // no error ->S : Symbol(S, Decl(test.d.ts, 1, 11)) ->A : Symbol(A, Decl(test.d.ts, 2, 13)) +>S : Symbol(S, Decl(test.d.ts, 0, 11)) +>A : Symbol(A, Decl(test.d.ts, 1, 13)) declare const A: number; ->A : Symbol(A, Decl(test.d.ts, 2, 13)) +>A : Symbol(A, Decl(test.d.ts, 1, 13)) diff --git a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types index dfacda3091535..314bbf7892f87 100644 --- a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types +++ b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/test.d.ts === - declare var S: typeof A; // no error >S : number >A : number diff --git a/tests/baselines/reference/nodeResolution1.js b/tests/baselines/reference/nodeResolution1.js index d3dad3355e617..91f423084d84b 100644 --- a/tests/baselines/reference/nodeResolution1.js +++ b/tests/baselines/reference/nodeResolution1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution1.ts] //// //// [a.ts] - export var x = 1; //// [b.ts] diff --git a/tests/baselines/reference/nodeResolution1.symbols b/tests/baselines/reference/nodeResolution1.symbols index 0cc98206e90fb..b58006055760f 100644 --- a/tests/baselines/reference/nodeResolution1.symbols +++ b/tests/baselines/reference/nodeResolution1.symbols @@ -3,7 +3,6 @@ import y = require("./a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/a.ts === - export var x = 1; ->x : Symbol(x, Decl(a.ts, 1, 10)) +>x : Symbol(x, Decl(a.ts, 0, 10)) diff --git a/tests/baselines/reference/nodeResolution1.types b/tests/baselines/reference/nodeResolution1.types index cd4feb3aba8da..350cf7a288790 100644 --- a/tests/baselines/reference/nodeResolution1.types +++ b/tests/baselines/reference/nodeResolution1.types @@ -3,7 +3,6 @@ import y = require("./a"); >y : typeof y === tests/cases/compiler/a.ts === - export var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/nodeResolution2.js b/tests/baselines/reference/nodeResolution2.js index 6d0963c6acbbe..0d66b012ca76a 100644 --- a/tests/baselines/reference/nodeResolution2.js +++ b/tests/baselines/reference/nodeResolution2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution2.ts] //// //// [a.d.ts] - export var x: number; //// [b.ts] diff --git a/tests/baselines/reference/nodeResolution2.symbols b/tests/baselines/reference/nodeResolution2.symbols index 643d285e7b8c6..ead8db27d7e79 100644 --- a/tests/baselines/reference/nodeResolution2.symbols +++ b/tests/baselines/reference/nodeResolution2.symbols @@ -3,7 +3,6 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/a.d.ts === - export var x: number; ->x : Symbol(x, Decl(a.d.ts, 1, 10)) +>x : Symbol(x, Decl(a.d.ts, 0, 10)) diff --git a/tests/baselines/reference/nodeResolution2.types b/tests/baselines/reference/nodeResolution2.types index 896af7f8bdaf6..3f4e97f7cfc54 100644 --- a/tests/baselines/reference/nodeResolution2.types +++ b/tests/baselines/reference/nodeResolution2.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/a.d.ts === - export var x: number; >x : number diff --git a/tests/baselines/reference/nodeResolution3.js b/tests/baselines/reference/nodeResolution3.js index 8750e3ff07d71..74eeec7057bc4 100644 --- a/tests/baselines/reference/nodeResolution3.js +++ b/tests/baselines/reference/nodeResolution3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution3.ts] //// //// [index.d.ts] - export var x: number; //// [a.ts] diff --git a/tests/baselines/reference/nodeResolution3.symbols b/tests/baselines/reference/nodeResolution3.symbols index 0fca588676f1c..53c85beb38d9d 100644 --- a/tests/baselines/reference/nodeResolution3.symbols +++ b/tests/baselines/reference/nodeResolution3.symbols @@ -3,7 +3,6 @@ import y = require("b"); >y : Symbol(y, Decl(a.ts, 0, 0)) === tests/cases/compiler/node_modules/b/index.d.ts === - export var x: number; ->x : Symbol(x, Decl(index.d.ts, 1, 10)) +>x : Symbol(x, Decl(index.d.ts, 0, 10)) diff --git a/tests/baselines/reference/nodeResolution3.types b/tests/baselines/reference/nodeResolution3.types index 82a1ccb27d34a..ab6afc01f461e 100644 --- a/tests/baselines/reference/nodeResolution3.types +++ b/tests/baselines/reference/nodeResolution3.types @@ -3,7 +3,6 @@ import y = require("b"); >y : typeof y === tests/cases/compiler/node_modules/b/index.d.ts === - export var x: number; >x : number diff --git a/tests/baselines/reference/nodeResolution4.js b/tests/baselines/reference/nodeResolution4.js index 0591dc5a299eb..3285f3b8e20b9 100644 --- a/tests/baselines/reference/nodeResolution4.js +++ b/tests/baselines/reference/nodeResolution4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution4.ts] //// //// [ref.ts] - var x = 1; //// [a.ts] diff --git a/tests/baselines/reference/nodeResolution4.symbols b/tests/baselines/reference/nodeResolution4.symbols index b8e0b59284a9f..635a158f2d65e 100644 --- a/tests/baselines/reference/nodeResolution4.symbols +++ b/tests/baselines/reference/nodeResolution4.symbols @@ -3,9 +3,8 @@ import y = require("./a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/ref.ts === - var x = 1; ->x : Symbol(x, Decl(ref.ts, 1, 3)) +>x : Symbol(x, Decl(ref.ts, 0, 3)) === tests/cases/compiler/a.ts === /// diff --git a/tests/baselines/reference/nodeResolution4.types b/tests/baselines/reference/nodeResolution4.types index f52f28df25a2b..d73320bd9c211 100644 --- a/tests/baselines/reference/nodeResolution4.types +++ b/tests/baselines/reference/nodeResolution4.types @@ -3,7 +3,6 @@ import y = require("./a"); >y : typeof y === tests/cases/compiler/ref.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/nodeResolution5.js b/tests/baselines/reference/nodeResolution5.js index f5a6165906fc5..3dfedea4aab02 100644 --- a/tests/baselines/reference/nodeResolution5.js +++ b/tests/baselines/reference/nodeResolution5.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution5.ts] //// //// [a.d.ts] - declare module "a" { var x: number; } diff --git a/tests/baselines/reference/nodeResolution5.symbols b/tests/baselines/reference/nodeResolution5.symbols index be4aa2be0e966..5871ad57a4e26 100644 --- a/tests/baselines/reference/nodeResolution5.symbols +++ b/tests/baselines/reference/nodeResolution5.symbols @@ -3,9 +3,8 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/a.d.ts === - declare module "a" { var x: number; ->x : Symbol(x, Decl(a.d.ts, 2, 7)) +>x : Symbol(x, Decl(a.d.ts, 1, 7)) } diff --git a/tests/baselines/reference/nodeResolution5.types b/tests/baselines/reference/nodeResolution5.types index 14f5bd24f5d37..4c2872f7b5dbf 100644 --- a/tests/baselines/reference/nodeResolution5.types +++ b/tests/baselines/reference/nodeResolution5.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/a.d.ts === - declare module "a" { var x: number; >x : number diff --git a/tests/baselines/reference/nodeResolution6.js b/tests/baselines/reference/nodeResolution6.js index cda821991d003..0610c53edcf4c 100644 --- a/tests/baselines/reference/nodeResolution6.js +++ b/tests/baselines/reference/nodeResolution6.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution6.ts] //// //// [ref.ts] - var x = 1; //// [a.d.ts] diff --git a/tests/baselines/reference/nodeResolution6.symbols b/tests/baselines/reference/nodeResolution6.symbols index 075f94e799263..24864d15a7966 100644 --- a/tests/baselines/reference/nodeResolution6.symbols +++ b/tests/baselines/reference/nodeResolution6.symbols @@ -3,9 +3,8 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/ref.ts === - var x = 1; ->x : Symbol(x, Decl(ref.ts, 1, 3)) +>x : Symbol(x, Decl(ref.ts, 0, 3)) === tests/cases/compiler/node_modules/a.d.ts === /// diff --git a/tests/baselines/reference/nodeResolution6.types b/tests/baselines/reference/nodeResolution6.types index 9e685e8c49317..1c08f9c9113c3 100644 --- a/tests/baselines/reference/nodeResolution6.types +++ b/tests/baselines/reference/nodeResolution6.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/ref.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/nodeResolution7.js b/tests/baselines/reference/nodeResolution7.js index f8cbff14726e5..118f9cd3994cc 100644 --- a/tests/baselines/reference/nodeResolution7.js +++ b/tests/baselines/reference/nodeResolution7.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution7.ts] //// //// [index.d.ts] - declare module "a" { var x: number; } diff --git a/tests/baselines/reference/nodeResolution7.symbols b/tests/baselines/reference/nodeResolution7.symbols index ea8d636b61b11..30b930c72e411 100644 --- a/tests/baselines/reference/nodeResolution7.symbols +++ b/tests/baselines/reference/nodeResolution7.symbols @@ -3,9 +3,8 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/a/index.d.ts === - declare module "a" { var x: number; ->x : Symbol(x, Decl(index.d.ts, 2, 7)) +>x : Symbol(x, Decl(index.d.ts, 1, 7)) } diff --git a/tests/baselines/reference/nodeResolution7.types b/tests/baselines/reference/nodeResolution7.types index 1cb14150bdee5..8dfe6c0d15f17 100644 --- a/tests/baselines/reference/nodeResolution7.types +++ b/tests/baselines/reference/nodeResolution7.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/a/index.d.ts === - declare module "a" { var x: number; >x : number diff --git a/tests/baselines/reference/nodeResolution8.js b/tests/baselines/reference/nodeResolution8.js index 5facd2edc39ee..59a6ee67ec8dc 100644 --- a/tests/baselines/reference/nodeResolution8.js +++ b/tests/baselines/reference/nodeResolution8.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nodeResolution8.ts] //// //// [ref.ts] - var x = 1; //// [index.d.ts] diff --git a/tests/baselines/reference/nodeResolution8.symbols b/tests/baselines/reference/nodeResolution8.symbols index 27c0941c9b992..bf698c36dfe9d 100644 --- a/tests/baselines/reference/nodeResolution8.symbols +++ b/tests/baselines/reference/nodeResolution8.symbols @@ -3,9 +3,8 @@ import y = require("a"); >y : Symbol(y, Decl(b.ts, 0, 0)) === tests/cases/compiler/node_modules/a/ref.ts === - var x = 1; ->x : Symbol(x, Decl(ref.ts, 1, 3)) +>x : Symbol(x, Decl(ref.ts, 0, 3)) === tests/cases/compiler/node_modules/a/index.d.ts === /// diff --git a/tests/baselines/reference/nodeResolution8.types b/tests/baselines/reference/nodeResolution8.types index 757af64a0ef38..88da1e0781be7 100644 --- a/tests/baselines/reference/nodeResolution8.types +++ b/tests/baselines/reference/nodeResolution8.types @@ -3,7 +3,6 @@ import y = require("a"); >y : typeof y === tests/cases/compiler/node_modules/a/ref.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/nonPrimitiveRhsSideOfInExpression.js b/tests/baselines/reference/nonPrimitiveRhsSideOfInExpression.js new file mode 100644 index 0000000000000..4b08610199be9 --- /dev/null +++ b/tests/baselines/reference/nonPrimitiveRhsSideOfInExpression.js @@ -0,0 +1,17 @@ +//// [nonPrimitiveRhsSideOfInExpression.ts] +let o: object = {}; + +function f(): object { + return {}; +} + +const b1 = "foo" in o; +const b2 = "bar" in f(); + +//// [nonPrimitiveRhsSideOfInExpression.js] +var o = {}; +function f() { + return {}; +} +var b1 = "foo" in o; +var b2 = "bar" in f(); diff --git a/tests/baselines/reference/nonPrimitiveRhsSideOfInExpression.symbols b/tests/baselines/reference/nonPrimitiveRhsSideOfInExpression.symbols new file mode 100644 index 0000000000000..914f77322a53f --- /dev/null +++ b/tests/baselines/reference/nonPrimitiveRhsSideOfInExpression.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/types/nonPrimitive/nonPrimitiveRhsSideOfInExpression.ts === +let o: object = {}; +>o : Symbol(o, Decl(nonPrimitiveRhsSideOfInExpression.ts, 0, 3)) + +function f(): object { +>f : Symbol(f, Decl(nonPrimitiveRhsSideOfInExpression.ts, 0, 19)) + + return {}; +} + +const b1 = "foo" in o; +>b1 : Symbol(b1, Decl(nonPrimitiveRhsSideOfInExpression.ts, 6, 5)) +>o : Symbol(o, Decl(nonPrimitiveRhsSideOfInExpression.ts, 0, 3)) + +const b2 = "bar" in f(); +>b2 : Symbol(b2, Decl(nonPrimitiveRhsSideOfInExpression.ts, 7, 5)) +>f : Symbol(f, Decl(nonPrimitiveRhsSideOfInExpression.ts, 0, 19)) + diff --git a/tests/baselines/reference/nonPrimitiveRhsSideOfInExpression.types b/tests/baselines/reference/nonPrimitiveRhsSideOfInExpression.types new file mode 100644 index 0000000000000..45c8864e43e4c --- /dev/null +++ b/tests/baselines/reference/nonPrimitiveRhsSideOfInExpression.types @@ -0,0 +1,25 @@ +=== tests/cases/conformance/types/nonPrimitive/nonPrimitiveRhsSideOfInExpression.ts === +let o: object = {}; +>o : object +>{} : {} + +function f(): object { +>f : () => object + + return {}; +>{} : {} +} + +const b1 = "foo" in o; +>b1 : boolean +>"foo" in o : boolean +>"foo" : "foo" +>o : object + +const b2 = "bar" in f(); +>b2 : boolean +>"bar" in f() : boolean +>"bar" : "bar" +>f() : object +>f : () => object + diff --git a/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt b/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt index 473011aaa7f5c..6b26c4d42ac8c 100644 --- a/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt +++ b/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt @@ -1,29 +1,28 @@ -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(7,1): error TS2454: Variable 'a' is used before being assigned. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(8,1): error TS2322: Type 'undefined' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(9,1): error TS2322: Type 'null' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(10,1): error TS2322: Type 'object | null' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(6,1): error TS2454: Variable 'a' is used before being assigned. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(7,1): error TS2322: Type 'undefined' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(8,1): error TS2322: Type 'null' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(9,1): error TS2322: Type 'object | null' is not assignable to type 'object'. Type 'null' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(11,1): error TS2322: Type 'object | undefined' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(10,1): error TS2322: Type 'object | undefined' is not assignable to type 'object'. Type 'undefined' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(12,1): error TS2322: Type 'object | null | undefined' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(11,1): error TS2322: Type 'object | null | undefined' is not assignable to type 'object'. Type 'undefined' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(18,7): error TS2339: Property 'toString' does not exist on type 'never'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(22,5): error TS2322: Type 'object | null' is not assignable to type 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(17,7): error TS2339: Property 'toString' does not exist on type 'never'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(21,5): error TS2322: Type 'object | null' is not assignable to type 'object'. Type 'null' is not assignable to type 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(27,5): error TS2531: Object is possibly 'null'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(29,5): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(33,5): error TS2533: Object is possibly 'null' or 'undefined'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(39,5): error TS2531: Object is possibly 'null'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(41,5): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(45,5): error TS2532: Object is possibly 'undefined'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(47,5): error TS2531: Object is possibly 'null'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(52,14): error TS2344: Type 'number' does not satisfy the constraint 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(53,14): error TS2344: Type 'null' does not satisfy the constraint 'object'. -tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(54,14): error TS2344: Type 'undefined' does not satisfy the constraint 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(26,5): error TS2531: Object is possibly 'null'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(28,5): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(32,5): error TS2533: Object is possibly 'null' or 'undefined'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(38,5): error TS2531: Object is possibly 'null'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(40,5): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(44,5): error TS2532: Object is possibly 'undefined'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(46,5): error TS2531: Object is possibly 'null'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(51,14): error TS2344: Type 'number' does not satisfy the constraint 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(52,14): error TS2344: Type 'null' does not satisfy the constraint 'object'. +tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(53,14): error TS2344: Type 'undefined' does not satisfy the constraint 'object'. ==== tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts (18 errors) ==== - var a: object declare var b: object | null declare var c: object | undefined diff --git a/tests/baselines/reference/nonPrimitiveStrictNull.js b/tests/baselines/reference/nonPrimitiveStrictNull.js index 754ca8cac7dda..6239affd9a0c3 100644 --- a/tests/baselines/reference/nonPrimitiveStrictNull.js +++ b/tests/baselines/reference/nonPrimitiveStrictNull.js @@ -1,5 +1,4 @@ //// [nonPrimitiveStrictNull.ts] - var a: object declare var b: object | null declare var c: object | undefined diff --git a/tests/baselines/reference/nounusedTypeParameterConstraint.js b/tests/baselines/reference/nounusedTypeParameterConstraint.js index f8881e6d0a00e..a448315fa70db 100644 --- a/tests/baselines/reference/nounusedTypeParameterConstraint.js +++ b/tests/baselines/reference/nounusedTypeParameterConstraint.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/nounusedTypeParameterConstraint.ts] //// //// [bar.ts] - export interface IEventSourcedEntity { } //// [test.ts] diff --git a/tests/baselines/reference/nounusedTypeParameterConstraint.symbols b/tests/baselines/reference/nounusedTypeParameterConstraint.symbols index 40364460f5030..559d678e8b30f 100644 --- a/tests/baselines/reference/nounusedTypeParameterConstraint.symbols +++ b/tests/baselines/reference/nounusedTypeParameterConstraint.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/bar.ts === - export interface IEventSourcedEntity { } >IEventSourcedEntity : Symbol(IEventSourcedEntity, Decl(bar.ts, 0, 0)) diff --git a/tests/baselines/reference/nounusedTypeParameterConstraint.types b/tests/baselines/reference/nounusedTypeParameterConstraint.types index 0ded5540092d9..ac8d227a5f167 100644 --- a/tests/baselines/reference/nounusedTypeParameterConstraint.types +++ b/tests/baselines/reference/nounusedTypeParameterConstraint.types @@ -1,5 +1,4 @@ === tests/cases/compiler/bar.ts === - export interface IEventSourcedEntity { } >IEventSourcedEntity : IEventSourcedEntity diff --git a/tests/baselines/reference/null.errors.txt b/tests/baselines/reference/null.errors.txt index f957507438c08..6b05bfb94d12d 100644 --- a/tests/baselines/reference/null.errors.txt +++ b/tests/baselines/reference/null.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/null.ts(4,9): error TS2531: Object is possibly 'null'. +tests/cases/compiler/null.ts(3,9): error TS2531: Object is possibly 'null'. ==== tests/cases/compiler/null.ts (1 errors) ==== - var x=null; var y=3+x; var z=3+null; diff --git a/tests/baselines/reference/null.js b/tests/baselines/reference/null.js index a58c5f7ed1633..2eb14e240bcf1 100644 --- a/tests/baselines/reference/null.js +++ b/tests/baselines/reference/null.js @@ -1,5 +1,4 @@ //// [null.ts] - var x=null; var y=3+x; var z=3+null; diff --git a/tests/baselines/reference/numericLiteralTypes2.js b/tests/baselines/reference/numericLiteralTypes2.js index ea82d00832cbf..ff0404e42dd7c 100644 --- a/tests/baselines/reference/numericLiteralTypes2.js +++ b/tests/baselines/reference/numericLiteralTypes2.js @@ -1,5 +1,4 @@ //// [numericLiteralTypes2.ts] - type A1 = 1; type A2 = 1.0; type A3 = 1e0; diff --git a/tests/baselines/reference/numericLiteralTypes2.symbols b/tests/baselines/reference/numericLiteralTypes2.symbols index f0dbbda502e30..59c814513e4b5 100644 --- a/tests/baselines/reference/numericLiteralTypes2.symbols +++ b/tests/baselines/reference/numericLiteralTypes2.symbols @@ -1,237 +1,236 @@ === tests/cases/conformance/types/literal/numericLiteralTypes2.ts === - type A1 = 1; >A1 : Symbol(A1, Decl(numericLiteralTypes2.ts, 0, 0)) type A2 = 1.0; ->A2 : Symbol(A2, Decl(numericLiteralTypes2.ts, 1, 12)) +>A2 : Symbol(A2, Decl(numericLiteralTypes2.ts, 0, 12)) type A3 = 1e0; ->A3 : Symbol(A3, Decl(numericLiteralTypes2.ts, 2, 14)) +>A3 : Symbol(A3, Decl(numericLiteralTypes2.ts, 1, 14)) type A4 = 10e-1; ->A4 : Symbol(A4, Decl(numericLiteralTypes2.ts, 3, 14)) +>A4 : Symbol(A4, Decl(numericLiteralTypes2.ts, 2, 14)) type A5 = 1 | 1.0 | 1e0 | 10e-1; ->A5 : Symbol(A5, Decl(numericLiteralTypes2.ts, 4, 16)) +>A5 : Symbol(A5, Decl(numericLiteralTypes2.ts, 3, 16)) function f1() { ->f1 : Symbol(f1, Decl(numericLiteralTypes2.ts, 5, 32)) +>f1 : Symbol(f1, Decl(numericLiteralTypes2.ts, 4, 32)) var a: A1 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) >A1 : Symbol(A1, Decl(numericLiteralTypes2.ts, 0, 0)) var a: A2 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) ->A2 : Symbol(A2, Decl(numericLiteralTypes2.ts, 1, 12)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) +>A2 : Symbol(A2, Decl(numericLiteralTypes2.ts, 0, 12)) var a: A3 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) ->A3 : Symbol(A3, Decl(numericLiteralTypes2.ts, 2, 14)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) +>A3 : Symbol(A3, Decl(numericLiteralTypes2.ts, 1, 14)) var a: A4 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) ->A4 : Symbol(A4, Decl(numericLiteralTypes2.ts, 3, 14)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) +>A4 : Symbol(A4, Decl(numericLiteralTypes2.ts, 2, 14)) var a: A5 = 1; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7), Decl(numericLiteralTypes2.ts, 12, 7)) ->A5 : Symbol(A5, Decl(numericLiteralTypes2.ts, 4, 16)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 7, 7), Decl(numericLiteralTypes2.ts, 8, 7), Decl(numericLiteralTypes2.ts, 9, 7), Decl(numericLiteralTypes2.ts, 10, 7), Decl(numericLiteralTypes2.ts, 11, 7)) +>A5 : Symbol(A5, Decl(numericLiteralTypes2.ts, 3, 16)) } type B1 = -1 | 0 | 1; ->B1 : Symbol(B1, Decl(numericLiteralTypes2.ts, 13, 1)) +>B1 : Symbol(B1, Decl(numericLiteralTypes2.ts, 12, 1)) type B2 = 1 | 0 | -1; ->B2 : Symbol(B2, Decl(numericLiteralTypes2.ts, 15, 21)) +>B2 : Symbol(B2, Decl(numericLiteralTypes2.ts, 14, 21)) type B3 = 0 | -1 | 1; ->B3 : Symbol(B3, Decl(numericLiteralTypes2.ts, 16, 21)) +>B3 : Symbol(B3, Decl(numericLiteralTypes2.ts, 15, 21)) function f2() { ->f2 : Symbol(f2, Decl(numericLiteralTypes2.ts, 17, 21)) +>f2 : Symbol(f2, Decl(numericLiteralTypes2.ts, 16, 21)) var b: B1 = -1; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7), Decl(numericLiteralTypes2.ts, 22, 7)) ->B1 : Symbol(B1, Decl(numericLiteralTypes2.ts, 13, 1)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 19, 7), Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7)) +>B1 : Symbol(B1, Decl(numericLiteralTypes2.ts, 12, 1)) var b: B2 = 0; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7), Decl(numericLiteralTypes2.ts, 22, 7)) ->B2 : Symbol(B2, Decl(numericLiteralTypes2.ts, 15, 21)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 19, 7), Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7)) +>B2 : Symbol(B2, Decl(numericLiteralTypes2.ts, 14, 21)) var b: B3 = 1; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7), Decl(numericLiteralTypes2.ts, 22, 7)) ->B3 : Symbol(B3, Decl(numericLiteralTypes2.ts, 16, 21)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 19, 7), Decl(numericLiteralTypes2.ts, 20, 7), Decl(numericLiteralTypes2.ts, 21, 7)) +>B3 : Symbol(B3, Decl(numericLiteralTypes2.ts, 15, 21)) } function f3(a: 1, b: 0 | 1 | 2) { ->f3 : Symbol(f3, Decl(numericLiteralTypes2.ts, 23, 1)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>f3 : Symbol(f3, Decl(numericLiteralTypes2.ts, 22, 1)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a + b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a - b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a * b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a / b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a % b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a | b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a & b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = a ^ b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = -b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var x = ~b; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7), Decl(numericLiteralTypes2.ts, 35, 7)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 25, 7), Decl(numericLiteralTypes2.ts, 26, 7), Decl(numericLiteralTypes2.ts, 27, 7), Decl(numericLiteralTypes2.ts, 28, 7), Decl(numericLiteralTypes2.ts, 29, 7), Decl(numericLiteralTypes2.ts, 30, 7), Decl(numericLiteralTypes2.ts, 31, 7), Decl(numericLiteralTypes2.ts, 32, 7), Decl(numericLiteralTypes2.ts, 33, 7), Decl(numericLiteralTypes2.ts, 34, 7)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a == b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a != b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a === b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a !== b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a > b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a < b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a >= b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = a <= b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 25, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 24, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) var y = !b; ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7), Decl(numericLiteralTypes2.ts, 44, 7)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 25, 17)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 35, 7), Decl(numericLiteralTypes2.ts, 36, 7), Decl(numericLiteralTypes2.ts, 37, 7), Decl(numericLiteralTypes2.ts, 38, 7), Decl(numericLiteralTypes2.ts, 39, 7), Decl(numericLiteralTypes2.ts, 40, 7), Decl(numericLiteralTypes2.ts, 41, 7), Decl(numericLiteralTypes2.ts, 42, 7), Decl(numericLiteralTypes2.ts, 43, 7)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 24, 17)) } function f4(a: 1, b: 0 | 1 | 2) { ->f4 : Symbol(f4, Decl(numericLiteralTypes2.ts, 45, 1)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 47, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 47, 17)) +>f4 : Symbol(f4, Decl(numericLiteralTypes2.ts, 44, 1)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 46, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 46, 17)) a++; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 47, 12)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 46, 12)) b++; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 47, 17)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 46, 17)) } declare function g(x: 0): string; ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 52, 19)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 51, 19)) declare function g(x: 1): boolean; ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 53, 19)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 52, 19)) declare function g(x: number): number; ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 54, 19)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 53, 19)) function f5(a: 1, b: 0 | 1 | 2) { ->f5 : Symbol(f5, Decl(numericLiteralTypes2.ts, 54, 38)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 56, 12)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 56, 17)) +>f5 : Symbol(f5, Decl(numericLiteralTypes2.ts, 53, 38)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 55, 12)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 55, 17)) var z1 = g(0); ->z1 : Symbol(z1, Decl(numericLiteralTypes2.ts, 57, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) +>z1 : Symbol(z1, Decl(numericLiteralTypes2.ts, 56, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) var z2 = g(1); ->z2 : Symbol(z2, Decl(numericLiteralTypes2.ts, 58, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) +>z2 : Symbol(z2, Decl(numericLiteralTypes2.ts, 57, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) var z3 = g(2); ->z3 : Symbol(z3, Decl(numericLiteralTypes2.ts, 59, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) +>z3 : Symbol(z3, Decl(numericLiteralTypes2.ts, 58, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) var z4 = g(a); ->z4 : Symbol(z4, Decl(numericLiteralTypes2.ts, 60, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 56, 12)) +>z4 : Symbol(z4, Decl(numericLiteralTypes2.ts, 59, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 55, 12)) var z5 = g(b); ->z5 : Symbol(z5, Decl(numericLiteralTypes2.ts, 61, 7)) ->g : Symbol(g, Decl(numericLiteralTypes2.ts, 50, 1), Decl(numericLiteralTypes2.ts, 52, 33), Decl(numericLiteralTypes2.ts, 53, 34)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 56, 17)) +>z5 : Symbol(z5, Decl(numericLiteralTypes2.ts, 60, 7)) +>g : Symbol(g, Decl(numericLiteralTypes2.ts, 49, 1), Decl(numericLiteralTypes2.ts, 51, 33), Decl(numericLiteralTypes2.ts, 52, 34)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 55, 17)) } function assertNever(x: never): never { ->assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 62, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 64, 21)) +>assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 61, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 63, 21)) throw new Error("Unexpected value"); >Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } type Tag = 0 | 1 | 2; ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) function f10(x: Tag) { ->f10 : Symbol(f10, Decl(numericLiteralTypes2.ts, 68, 21)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 70, 13)) ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>f10 : Symbol(f10, Decl(numericLiteralTypes2.ts, 67, 21)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 69, 13)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) switch (x) { ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 70, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 69, 13)) case 0: return "a"; case 1: return "b"; @@ -240,175 +239,175 @@ function f10(x: Tag) { } function f11(x: Tag) { ->f11 : Symbol(f11, Decl(numericLiteralTypes2.ts, 76, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 78, 13)) ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>f11 : Symbol(f11, Decl(numericLiteralTypes2.ts, 75, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 77, 13)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) switch (x) { ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 78, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 77, 13)) case 0: return "a"; case 1: return "b"; case 2: return "c"; } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 62, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 78, 13)) +>assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 61, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 77, 13)) } function f12(x: Tag) { ->f12 : Symbol(f12, Decl(numericLiteralTypes2.ts, 85, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 87, 13)) ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>f12 : Symbol(f12, Decl(numericLiteralTypes2.ts, 84, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 86, 13)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) if (x) { ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 86, 13)) x; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 86, 13)) } else { x; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 87, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 86, 13)) } } function f13(x: Tag) { ->f13 : Symbol(f13, Decl(numericLiteralTypes2.ts, 94, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) ->Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 66, 1)) +>f13 : Symbol(f13, Decl(numericLiteralTypes2.ts, 93, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) +>Tag : Symbol(Tag, Decl(numericLiteralTypes2.ts, 65, 1)) if (x === 0 || x === 2) { ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) x; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) } else { x; ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 96, 13)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 95, 13)) } } function f14(x: 0 | 1 | 2, y: string) { ->f14 : Symbol(f14, Decl(numericLiteralTypes2.ts, 103, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 105, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 105, 26)) +>f14 : Symbol(f14, Decl(numericLiteralTypes2.ts, 102, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 104, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 104, 26)) var a = x && y; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 106, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 105, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 105, 26)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 105, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 104, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 104, 26)) var b = x || y; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 107, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 105, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 105, 26)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 106, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 104, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 104, 26)) } function f15(x: 0 | false, y: 1 | "one") { ->f15 : Symbol(f15, Decl(numericLiteralTypes2.ts, 108, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) +>f15 : Symbol(f15, Decl(numericLiteralTypes2.ts, 107, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) var a = x && y; ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 111, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 110, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) var b = y && x; ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 112, 7)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 111, 7)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) var c = x || y; ->c : Symbol(c, Decl(numericLiteralTypes2.ts, 113, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) +>c : Symbol(c, Decl(numericLiteralTypes2.ts, 112, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) var d = y || x; ->d : Symbol(d, Decl(numericLiteralTypes2.ts, 114, 7)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) +>d : Symbol(d, Decl(numericLiteralTypes2.ts, 113, 7)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) var e = !x; ->e : Symbol(e, Decl(numericLiteralTypes2.ts, 115, 7)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 110, 13)) +>e : Symbol(e, Decl(numericLiteralTypes2.ts, 114, 7)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 109, 13)) var f = !y; ->f : Symbol(f, Decl(numericLiteralTypes2.ts, 116, 7)) ->y : Symbol(y, Decl(numericLiteralTypes2.ts, 110, 26)) +>f : Symbol(f, Decl(numericLiteralTypes2.ts, 115, 7)) +>y : Symbol(y, Decl(numericLiteralTypes2.ts, 109, 26)) } type Item = ->Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 117, 1)) +>Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 116, 1)) { kind: 0, a: string } | ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) { kind: 1, b: string } | ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 121, 5)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) { kind: 2, c: string }; ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 122, 5)) ->c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 121, 5)) +>c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) function f20(x: Item) { ->f20 : Symbol(f20, Decl(numericLiteralTypes2.ts, 122, 27)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 117, 1)) +>f20 : Symbol(f20, Decl(numericLiteralTypes2.ts, 121, 27)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 116, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5), Decl(numericLiteralTypes2.ts, 122, 5)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5), Decl(numericLiteralTypes2.ts, 122, 5)) +>x.kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5), Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5), Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5)) case 0: return x.a; ->x.a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) +>x.a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) case 1: return x.b; ->x.b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) +>x.b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) case 2: return x.c; ->x.c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 124, 13)) ->c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) +>x.c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 123, 13)) +>c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) } } function f21(x: Item) { ->f21 : Symbol(f21, Decl(numericLiteralTypes2.ts, 130, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 117, 1)) +>f21 : Symbol(f21, Decl(numericLiteralTypes2.ts, 129, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>Item : Symbol(Item, Decl(numericLiteralTypes2.ts, 116, 1)) switch (x.kind) { ->x.kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5), Decl(numericLiteralTypes2.ts, 122, 5)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5), Decl(numericLiteralTypes2.ts, 122, 5)) +>x.kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5), Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>kind : Symbol(kind, Decl(numericLiteralTypes2.ts, 119, 5), Decl(numericLiteralTypes2.ts, 120, 5), Decl(numericLiteralTypes2.ts, 121, 5)) case 0: return x.a; ->x.a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->a : Symbol(a, Decl(numericLiteralTypes2.ts, 120, 14)) +>x.a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>a : Symbol(a, Decl(numericLiteralTypes2.ts, 119, 14)) case 1: return x.b; ->x.b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->b : Symbol(b, Decl(numericLiteralTypes2.ts, 121, 14)) +>x.b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>b : Symbol(b, Decl(numericLiteralTypes2.ts, 120, 14)) case 2: return x.c; ->x.c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) ->c : Symbol(c, Decl(numericLiteralTypes2.ts, 122, 14)) +>x.c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) +>c : Symbol(c, Decl(numericLiteralTypes2.ts, 121, 14)) } return assertNever(x); ->assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 62, 1)) ->x : Symbol(x, Decl(numericLiteralTypes2.ts, 132, 13)) +>assertNever : Symbol(assertNever, Decl(numericLiteralTypes2.ts, 61, 1)) +>x : Symbol(x, Decl(numericLiteralTypes2.ts, 131, 13)) } diff --git a/tests/baselines/reference/numericLiteralTypes2.types b/tests/baselines/reference/numericLiteralTypes2.types index 4c67154ad411b..c5bcff48f7f82 100644 --- a/tests/baselines/reference/numericLiteralTypes2.types +++ b/tests/baselines/reference/numericLiteralTypes2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/literal/numericLiteralTypes2.ts === - type A1 = 1; >A1 : 1 diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.errors.txt b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.errors.txt index b5dc0ac3c4b4f..db74b4b199f58 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.errors.txt +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers01.ts(2,13): error TS1005: ':' expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers01.ts(1,13): error TS1005: ':' expected. ==== tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers01.ts (1 errors) ==== - var { while } = { while: 1 } ~ !!! error TS1005: ':' expected. \ No newline at end of file diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.js index a905e53f22122..ec0cae158fc2b 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers01.ts] - var { while } = { while: 1 } //// [objectBindingPatternKeywordIdentifiers01.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.errors.txt b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.errors.txt index 7ac72469d0840..5809148707bc2 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.errors.txt +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts(2,20): error TS1005: ':' expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts(1,14): error TS1003: Identifier expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts(1,20): error TS1005: ':' expected. ==== tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers02.ts (2 errors) ==== - var { while: while } = { while: 1 } ~~~~~ !!! error TS1003: Identifier expected. diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.js index 5bc6e1f996367..88f5e1b56d87f 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers02.ts] - var { while: while } = { while: 1 } //// [objectBindingPatternKeywordIdentifiers02.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.errors.txt b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.errors.txt index 6ffad2c03454a..ad6a929911294 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.errors.txt +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers03.ts(2,15): error TS1005: ':' expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers03.ts(1,15): error TS1005: ':' expected. ==== tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers03.ts (1 errors) ==== - var { "while" } = { while: 1 } ~ !!! error TS1005: ':' expected. \ No newline at end of file diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.js index 3d8643d63ce28..6c9a539bb694e 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers03.ts] - var { "while" } = { while: 1 } //// [objectBindingPatternKeywordIdentifiers03.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.errors.txt b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.errors.txt index 69a8b48b2f1c7..5481b5efe557d 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.errors.txt +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts(2,16): error TS1003: Identifier expected. -tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts(2,22): error TS1005: ':' expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts(1,16): error TS1003: Identifier expected. +tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts(1,22): error TS1005: ':' expected. ==== tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers04.ts (2 errors) ==== - var { "while": while } = { while: 1 } ~~~~~ !!! error TS1003: Identifier expected. diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.js index de7608a77d22d..a93e76c7e9c0c 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers04.ts] - var { "while": while } = { while: 1 } //// [objectBindingPatternKeywordIdentifiers04.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.js index 41c46c4650621..08f8e632f2981 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers05.ts] - var { as } = { as: 1 } //// [objectBindingPatternKeywordIdentifiers05.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols index 5ac9bb815f8f9..dc39116a2c227 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers05.ts === - var { as } = { as: 1 } ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 5)) ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 14)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 0, 5)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 0, 14)) diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.types b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.types index d5838d7174a18..93cf447a7f197 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.types +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers05.ts === - var { as } = { as: 1 } >as : number >{ as: 1 } : { as: number; } diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.js b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.js index d24c468e891ba..9f29dfff1f853 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.js +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.js @@ -1,5 +1,4 @@ //// [objectBindingPatternKeywordIdentifiers06.ts] - var { as: as } = { as: 1 } //// [objectBindingPatternKeywordIdentifiers06.js] diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols index f054601249854..757cc6c370914 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols @@ -1,7 +1,6 @@ === tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers06.ts === - var { as: as } = { as: 1 } ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 18)) ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 5)) ->as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 18)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 0, 18)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 0, 5)) +>as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 0, 18)) diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.types b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.types index 427957c1ef887..73416da85c9da 100644 --- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.types +++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/destructuring/objectBindingPatternKeywordIdentifiers06.ts === - var { as: as } = { as: 1 } >as : any >as : number diff --git a/tests/baselines/reference/objectCreate-errors.errors.txt b/tests/baselines/reference/objectCreate-errors.errors.txt index 38b9158351eb3..12f62cc4d2cb3 100644 --- a/tests/baselines/reference/objectCreate-errors.errors.txt +++ b/tests/baselines/reference/objectCreate-errors.errors.txt @@ -1,15 +1,14 @@ -tests/cases/compiler/objectCreate-errors.ts(2,24): error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(3,24): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(4,24): error TS2345: Argument of type 'false' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(5,24): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(8,24): error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(9,24): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(10,24): error TS2345: Argument of type 'false' is not assignable to parameter of type 'object | null'. -tests/cases/compiler/objectCreate-errors.ts(11,24): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(1,24): error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(2,24): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(3,24): error TS2345: Argument of type 'false' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(4,24): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(7,24): error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(8,24): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(9,24): error TS2345: Argument of type 'false' is not assignable to parameter of type 'object | null'. +tests/cases/compiler/objectCreate-errors.ts(10,24): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'object | null'. ==== tests/cases/compiler/objectCreate-errors.ts (8 errors) ==== - var e1 = Object.create(1); // Error ~ !!! error TS2345: Argument of type '1' is not assignable to parameter of type 'object | null'. diff --git a/tests/baselines/reference/objectCreate-errors.js b/tests/baselines/reference/objectCreate-errors.js index 959b2f9473df3..7f358a1d00f96 100644 --- a/tests/baselines/reference/objectCreate-errors.js +++ b/tests/baselines/reference/objectCreate-errors.js @@ -1,5 +1,4 @@ //// [objectCreate-errors.ts] - var e1 = Object.create(1); // Error var e2 = Object.create("string"); // Error var e3 = Object.create(false); // Error diff --git a/tests/baselines/reference/objectCreate.js b/tests/baselines/reference/objectCreate.js index 728fa8ca21aa0..96e5a3ac9bc55 100644 --- a/tests/baselines/reference/objectCreate.js +++ b/tests/baselines/reference/objectCreate.js @@ -1,5 +1,4 @@ //// [objectCreate.ts] - declare var union: null | { a: number, b: string }; var n = Object.create(null); // object diff --git a/tests/baselines/reference/objectCreate.symbols b/tests/baselines/reference/objectCreate.symbols index 7ae0a796cc85d..00fe86a2d10d2 100644 --- a/tests/baselines/reference/objectCreate.symbols +++ b/tests/baselines/reference/objectCreate.symbols @@ -1,72 +1,71 @@ === tests/cases/compiler/objectCreate.ts === - declare var union: null | { a: number, b: string }; ->union : Symbol(union, Decl(objectCreate.ts, 1, 11)) ->a : Symbol(a, Decl(objectCreate.ts, 1, 27)) ->b : Symbol(b, Decl(objectCreate.ts, 1, 38)) +>union : Symbol(union, Decl(objectCreate.ts, 0, 11)) +>a : Symbol(a, Decl(objectCreate.ts, 0, 27)) +>b : Symbol(b, Decl(objectCreate.ts, 0, 38)) var n = Object.create(null); // object ->n : Symbol(n, Decl(objectCreate.ts, 3, 3)) +>n : Symbol(n, Decl(objectCreate.ts, 2, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var t = Object.create({ a: 1, b: "" }); // {a: number, b: string } ->t : Symbol(t, Decl(objectCreate.ts, 4, 3)) +>t : Symbol(t, Decl(objectCreate.ts, 3, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(objectCreate.ts, 4, 23)) ->b : Symbol(b, Decl(objectCreate.ts, 4, 29)) +>a : Symbol(a, Decl(objectCreate.ts, 3, 23)) +>b : Symbol(b, Decl(objectCreate.ts, 3, 29)) var u = Object.create(union); // object | {a: number, b: string } ->u : Symbol(u, Decl(objectCreate.ts, 5, 3)) +>u : Symbol(u, Decl(objectCreate.ts, 4, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->union : Symbol(union, Decl(objectCreate.ts, 1, 11)) +>union : Symbol(union, Decl(objectCreate.ts, 0, 11)) var e = Object.create({}); // {} ->e : Symbol(e, Decl(objectCreate.ts, 6, 3)) +>e : Symbol(e, Decl(objectCreate.ts, 5, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var o = Object.create({}); // object ->o : Symbol(o, Decl(objectCreate.ts, 7, 3)) +>o : Symbol(o, Decl(objectCreate.ts, 6, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create(null, {}); // any ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create({ a: 1, b: "" }, {}); ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(objectCreate.ts, 10, 23)) ->b : Symbol(b, Decl(objectCreate.ts, 10, 29)) +>a : Symbol(a, Decl(objectCreate.ts, 9, 23)) +>b : Symbol(b, Decl(objectCreate.ts, 9, 29)) var a = Object.create(union, {}); ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->union : Symbol(union, Decl(objectCreate.ts, 1, 11)) +>union : Symbol(union, Decl(objectCreate.ts, 0, 11)) var a = Object.create({}, {}); ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create({}, {}); ->a : Symbol(a, Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3), Decl(objectCreate.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate.ts, 8, 3), Decl(objectCreate.ts, 9, 3), Decl(objectCreate.ts, 10, 3), Decl(objectCreate.ts, 11, 3), Decl(objectCreate.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/objectCreate.types b/tests/baselines/reference/objectCreate.types index 8bf433e53fe3f..341a58478bc2e 100644 --- a/tests/baselines/reference/objectCreate.types +++ b/tests/baselines/reference/objectCreate.types @@ -1,5 +1,4 @@ === tests/cases/compiler/objectCreate.ts === - declare var union: null | { a: number, b: string }; >union : { a: number; b: string; } | null >null : null diff --git a/tests/baselines/reference/objectCreate2.js b/tests/baselines/reference/objectCreate2.js index cfc79c2ef355e..8328f523a6d9a 100644 --- a/tests/baselines/reference/objectCreate2.js +++ b/tests/baselines/reference/objectCreate2.js @@ -1,5 +1,4 @@ //// [objectCreate2.ts] - declare var union: null | { a: number, b: string }; var n = Object.create(null); // any diff --git a/tests/baselines/reference/objectCreate2.symbols b/tests/baselines/reference/objectCreate2.symbols index bf57b6d5e073d..3579aba081713 100644 --- a/tests/baselines/reference/objectCreate2.symbols +++ b/tests/baselines/reference/objectCreate2.symbols @@ -1,72 +1,71 @@ === tests/cases/compiler/objectCreate2.ts === - declare var union: null | { a: number, b: string }; ->union : Symbol(union, Decl(objectCreate2.ts, 1, 11)) ->a : Symbol(a, Decl(objectCreate2.ts, 1, 27)) ->b : Symbol(b, Decl(objectCreate2.ts, 1, 38)) +>union : Symbol(union, Decl(objectCreate2.ts, 0, 11)) +>a : Symbol(a, Decl(objectCreate2.ts, 0, 27)) +>b : Symbol(b, Decl(objectCreate2.ts, 0, 38)) var n = Object.create(null); // any ->n : Symbol(n, Decl(objectCreate2.ts, 3, 3)) +>n : Symbol(n, Decl(objectCreate2.ts, 2, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var t = Object.create({ a: 1, b: "" }); // {a: number, b: string } ->t : Symbol(t, Decl(objectCreate2.ts, 4, 3)) +>t : Symbol(t, Decl(objectCreate2.ts, 3, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(objectCreate2.ts, 4, 23)) ->b : Symbol(b, Decl(objectCreate2.ts, 4, 29)) +>a : Symbol(a, Decl(objectCreate2.ts, 3, 23)) +>b : Symbol(b, Decl(objectCreate2.ts, 3, 29)) var u = Object.create(union); // {a: number, b: string } ->u : Symbol(u, Decl(objectCreate2.ts, 5, 3)) +>u : Symbol(u, Decl(objectCreate2.ts, 4, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->union : Symbol(union, Decl(objectCreate2.ts, 1, 11)) +>union : Symbol(union, Decl(objectCreate2.ts, 0, 11)) var e = Object.create({}); // {} ->e : Symbol(e, Decl(objectCreate2.ts, 6, 3)) +>e : Symbol(e, Decl(objectCreate2.ts, 5, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var o = Object.create({}); // object ->o : Symbol(o, Decl(objectCreate2.ts, 7, 3)) +>o : Symbol(o, Decl(objectCreate2.ts, 6, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create(null, {}); // any ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create({ a: 1, b: "" }, {}); ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->a : Symbol(a, Decl(objectCreate2.ts, 10, 23)) ->b : Symbol(b, Decl(objectCreate2.ts, 10, 29)) +>a : Symbol(a, Decl(objectCreate2.ts, 9, 23)) +>b : Symbol(b, Decl(objectCreate2.ts, 9, 29)) var a = Object.create(union, {}); ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->union : Symbol(union, Decl(objectCreate2.ts, 1, 11)) +>union : Symbol(union, Decl(objectCreate2.ts, 0, 11)) var a = Object.create({}, {}); ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a = Object.create({}, {}); ->a : Symbol(a, Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3), Decl(objectCreate2.ts, 13, 3)) +>a : Symbol(a, Decl(objectCreate2.ts, 8, 3), Decl(objectCreate2.ts, 9, 3), Decl(objectCreate2.ts, 10, 3), Decl(objectCreate2.ts, 11, 3), Decl(objectCreate2.ts, 12, 3)) >Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/objectCreate2.types b/tests/baselines/reference/objectCreate2.types index 1602d70d57189..914a99b04e2aa 100644 --- a/tests/baselines/reference/objectCreate2.types +++ b/tests/baselines/reference/objectCreate2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/objectCreate2.ts === - declare var union: null | { a: number, b: string }; >union : { a: number; b: string; } >null : null diff --git a/tests/baselines/reference/objectLiteralErrors.errors.txt b/tests/baselines/reference/objectLiteralErrors.errors.txt index 0e0db0b414f13..2a2dc7dd5753c 100644 --- a/tests/baselines/reference/objectLiteralErrors.errors.txt +++ b/tests/baselines/reference/objectLiteralErrors.errors.txt @@ -1,85 +1,84 @@ -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(3,18): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(4,19): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(5,18): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(6,21): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(7,19): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(8,18): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(9,20): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(10,20): error TS2300: Duplicate identifier '"a"'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(11,20): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(12,21): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(13,21): error TS2300: Duplicate identifier ''1''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(2,18): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(3,19): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(4,18): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(5,21): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(6,19): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(7,18): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(8,20): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(9,20): error TS2300: Duplicate identifier '"a"'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(10,20): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(11,21): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(12,21): error TS2300: Duplicate identifier ''1''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(13,19): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(14,19): error TS2300: Duplicate identifier '0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(15,19): error TS2300: Duplicate identifier '0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(16,19): error TS2300: Duplicate identifier '0x0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(17,19): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(17,19): error TS2300: Duplicate identifier '000'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(18,23): error TS2300: Duplicate identifier '1e2'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(19,22): error TS2300: Duplicate identifier '3.2e1'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(20,25): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(15,19): error TS2300: Duplicate identifier '0x0'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(16,19): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o0'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(16,19): error TS2300: Duplicate identifier '000'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(17,23): error TS2300: Duplicate identifier '1e2'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(18,22): error TS2300: Duplicate identifier '3.2e1'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(19,25): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(22,12): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(22,22): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(22,22): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,22): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,22): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,23): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(23,23): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,23): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,22): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(24,22): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,22): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,22): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,25): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(25,25): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,25): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,25): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,23): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(26,23): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,23): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,12): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,22): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,22): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,22): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(27,22): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,12): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,24): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(28,24): error TS2300: Duplicate identifier 'a'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(29,12): error TS2300: Duplicate identifier ''a''. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(29,24): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(29,24): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(29,24): error TS2300: Duplicate identifier '"a"'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(30,12): error TS2300: Duplicate identifier ''a''. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(30,24): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(30,24): error TS2300: Duplicate identifier '"a"'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,12): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,24): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,24): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,13): error TS2300: Duplicate identifier '"a"'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(30,24): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,13): error TS2300: Duplicate identifier '"a"'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,25): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(31,25): error TS2300: Duplicate identifier ''a''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,13): error TS2300: Duplicate identifier '1.0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,25): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,25): error TS2300: Duplicate identifier ''a''. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,13): error TS2300: Duplicate identifier '1.0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,25): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,25): error TS2300: Duplicate identifier ''1''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(32,25): error TS2300: Duplicate identifier ''1''. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,13): error TS2300: Duplicate identifier '0'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,23): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(33,23): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(34,13): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(34,23): error TS1119: An object literal cannot have property and accessor with the same name. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(34,23): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(35,13): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(35,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(35,23): error TS2300: Duplicate identifier '0'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(35,23): error TS2300: Duplicate identifier '0x0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(36,13): error TS2300: Duplicate identifier '0'. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(36,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(36,23): error TS2300: Duplicate identifier '0x0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,13): error TS2300: Duplicate identifier '0'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,23): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,23): error TS2300: Duplicate identifier '000'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,13): error TS2300: Duplicate identifier '"100"'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,27): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,27): error TS2300: Duplicate identifier '1e2'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,13): error TS2300: Duplicate identifier '0x20'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,26): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,26): error TS2300: Duplicate identifier '3.2e1'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(40,13): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(40,46): error TS1119: An object literal cannot have property and accessor with the same name. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(40,46): error TS2300: Duplicate identifier 'a'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(43,16): error TS2380: 'get' and 'set' accessor must have the same type. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(43,47): error TS2380: 'get' and 'set' accessor must have the same type. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(44,22): error TS2322: Type '4' is not assignable to type 'string'. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(45,16): error TS2380: 'get' and 'set' accessor must have the same type. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(45,55): error TS2380: 'get' and 'set' accessor must have the same type. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(36,23): error TS2300: Duplicate identifier '000'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,13): error TS2300: Duplicate identifier '"100"'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,27): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(37,27): error TS2300: Duplicate identifier '1e2'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,13): error TS2300: Duplicate identifier '0x20'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,26): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(38,26): error TS2300: Duplicate identifier '3.2e1'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,13): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,46): error TS1119: An object literal cannot have property and accessor with the same name. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(39,46): error TS2300: Duplicate identifier 'a'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(42,16): error TS2380: 'get' and 'set' accessor must have the same type. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(42,47): error TS2380: 'get' and 'set' accessor must have the same type. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(43,22): error TS2322: Type '4' is not assignable to type 'string'. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(44,16): error TS2380: 'get' and 'set' accessor must have the same type. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts(44,55): error TS2380: 'get' and 'set' accessor must have the same type. ==== tests/cases/conformance/expressions/objectLiterals/objectLiteralErrors.ts (78 errors) ==== - // Multiple properties with the same name var e1 = { a: 0, a: 0 }; ~ diff --git a/tests/baselines/reference/objectLiteralErrors.js b/tests/baselines/reference/objectLiteralErrors.js index 4dccc78b67d29..1f721d3e71ce1 100644 --- a/tests/baselines/reference/objectLiteralErrors.js +++ b/tests/baselines/reference/objectLiteralErrors.js @@ -1,5 +1,4 @@ //// [objectLiteralErrors.ts] - // Multiple properties with the same name var e1 = { a: 0, a: 0 }; var e2 = { a: '', a: '' }; diff --git a/tests/baselines/reference/objectLiteralErrorsES3.errors.txt b/tests/baselines/reference/objectLiteralErrorsES3.errors.txt index 2788c23a278e9..99b4f5c4ae01d 100644 --- a/tests/baselines/reference/objectLiteralErrorsES3.errors.txt +++ b/tests/baselines/reference/objectLiteralErrorsES3.errors.txt @@ -1,11 +1,10 @@ +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(1,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(4,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(4,40): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts(3,40): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ==== tests/cases/conformance/expressions/objectLiterals/objectLiteralErrorsES3.ts (4 errors) ==== - var e1 = { get a() { return 4; } }; ~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. diff --git a/tests/baselines/reference/objectLiteralErrorsES3.js b/tests/baselines/reference/objectLiteralErrorsES3.js index 031a68fd10982..e45004c69b352 100644 --- a/tests/baselines/reference/objectLiteralErrorsES3.js +++ b/tests/baselines/reference/objectLiteralErrorsES3.js @@ -1,5 +1,4 @@ //// [objectLiteralErrorsES3.ts] - var e1 = { get a() { return 4; } }; var e2 = { set a(n) { } }; var e3 = { get a() { return ''; }, set a(n) { } }; diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.js b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.js index c9d7edf814037..de51ca232d1b8 100644 --- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.js +++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.js @@ -1,5 +1,4 @@ //// [objectLiteralShorthandPropertiesWithModuleES6.ts] - module m { export var x; } diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols index bcb69cc9a976c..c5b0756dcc29d 100644 --- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols +++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols @@ -1,28 +1,27 @@ === tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesWithModuleES6.ts === - module m { ->m : Symbol(m, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 0, 0), Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 3, 1)) +>m : Symbol(m, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 0, 0), Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 1)) export var x; ->x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 14)) +>x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 1, 14)) } module m { ->m : Symbol(m, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 0, 0), Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 3, 1)) +>m : Symbol(m, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 0, 0), Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 1)) var z = x; ->z : Symbol(z, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 6, 7)) ->x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 14)) +>z : Symbol(z, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 5, 7)) +>x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 1, 14)) var y = { ->y : Symbol(y, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 7)) +>y : Symbol(y, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 6, 7)) a: x, ->a : Symbol(a, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 13)) ->x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 2, 14)) +>a : Symbol(a, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 6, 13)) +>x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 1, 14)) x ->x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 8, 13)) +>x : Symbol(x, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 13)) }; } diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.types b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.types index 1030010d6c640..5a44fc2b8c45e 100644 --- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.types +++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesWithModuleES6.ts === - module m { >m : typeof m diff --git a/tests/baselines/reference/objectSpreadStrictNull.js b/tests/baselines/reference/objectSpreadStrictNull.js index 84604d728cdfc..8a4cf0e5f9fc6 100644 --- a/tests/baselines/reference/objectSpreadStrictNull.js +++ b/tests/baselines/reference/objectSpreadStrictNull.js @@ -1,5 +1,4 @@ //// [objectSpreadStrictNull.ts] - function f( definiteBoolean: { sn: boolean }, definiteString: { sn: string }, diff --git a/tests/baselines/reference/objectSpreadStrictNull.symbols b/tests/baselines/reference/objectSpreadStrictNull.symbols index 2586d4ddbd318..e9202767945f8 100644 --- a/tests/baselines/reference/objectSpreadStrictNull.symbols +++ b/tests/baselines/reference/objectSpreadStrictNull.symbols @@ -1,81 +1,80 @@ === tests/cases/conformance/types/spread/objectSpreadStrictNull.ts === - function f( >f : Symbol(f, Decl(objectSpreadStrictNull.ts, 0, 0)) definiteBoolean: { sn: boolean }, ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 2, 22)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 1, 22)) definiteString: { sn: string }, ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 3, 21)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 2, 21)) optionalString: { sn?: string }, ->optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 3, 35)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 4, 21)) +>optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 2, 35)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 3, 21)) optionalNumber: { sn?: number }, ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 5, 21)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 4, 21)) undefinedString: { sn: string | undefined }, ->undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 5, 36)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 6, 22)) +>undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 4, 36)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 5, 22)) undefinedNumber: { sn: number | undefined }) { ->undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 6, 48)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 7, 22)) +>undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 5, 48)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 6, 22)) // optional let optionalUnionStops: { sn: string | number } = { ...definiteBoolean, ...definiteString, ...optionalNumber }; ->optionalUnionStops : Symbol(optionalUnionStops, Decl(objectSpreadStrictNull.ts, 9, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 9, 29)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) +>optionalUnionStops : Symbol(optionalUnionStops, Decl(objectSpreadStrictNull.ts, 8, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 8, 29)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) let optionalUnionDuplicates: { sn: string | number } = { ...definiteBoolean, ...definiteString, ...optionalString, ...optionalNumber }; ->optionalUnionDuplicates : Symbol(optionalUnionDuplicates, Decl(objectSpreadStrictNull.ts, 10, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 10, 34)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 3, 35)) ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) +>optionalUnionDuplicates : Symbol(optionalUnionDuplicates, Decl(objectSpreadStrictNull.ts, 9, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 9, 34)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 2, 35)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) let allOptional: { sn?: string | number } = { ...optionalString, ...optionalNumber }; ->allOptional : Symbol(allOptional, Decl(objectSpreadStrictNull.ts, 11, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 11, 22)) ->optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 3, 35)) ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) +>allOptional : Symbol(allOptional, Decl(objectSpreadStrictNull.ts, 10, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 10, 22)) +>optionalString : Symbol(optionalString, Decl(objectSpreadStrictNull.ts, 2, 35)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) // undefined let undefinedUnionStops: { sn: string | number } = { ...definiteBoolean, ...definiteString, ...undefinedNumber }; ->undefinedUnionStops : Symbol(undefinedUnionStops, Decl(objectSpreadStrictNull.ts, 14, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 14, 30)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 6, 48)) +>undefinedUnionStops : Symbol(undefinedUnionStops, Decl(objectSpreadStrictNull.ts, 13, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 13, 30)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 5, 48)) let undefinedUnionDuplicates: { sn: string | number } = { ...definiteBoolean, ...definiteString, ...undefinedString, ...undefinedNumber }; ->undefinedUnionDuplicates : Symbol(undefinedUnionDuplicates, Decl(objectSpreadStrictNull.ts, 15, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 15, 35)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 2, 37)) ->undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 5, 36)) ->undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 6, 48)) +>undefinedUnionDuplicates : Symbol(undefinedUnionDuplicates, Decl(objectSpreadStrictNull.ts, 14, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 14, 35)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>definiteString : Symbol(definiteString, Decl(objectSpreadStrictNull.ts, 1, 37)) +>undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 4, 36)) +>undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 5, 48)) let allUndefined: { sn: string | number | undefined } = { ...undefinedString, ...undefinedNumber }; ->allUndefined : Symbol(allUndefined, Decl(objectSpreadStrictNull.ts, 16, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 16, 23)) ->undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 5, 36)) ->undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 6, 48)) +>allUndefined : Symbol(allUndefined, Decl(objectSpreadStrictNull.ts, 15, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 15, 23)) +>undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 4, 36)) +>undefinedNumber : Symbol(undefinedNumber, Decl(objectSpreadStrictNull.ts, 5, 48)) let undefinedWithOptionalContinues: { sn: string | number | boolean } = { ...definiteBoolean, ...undefinedString, ...optionalNumber }; ->undefinedWithOptionalContinues : Symbol(undefinedWithOptionalContinues, Decl(objectSpreadStrictNull.ts, 18, 7)) ->sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 18, 41)) ->definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 1, 11)) ->undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 5, 36)) ->optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 4, 36)) +>undefinedWithOptionalContinues : Symbol(undefinedWithOptionalContinues, Decl(objectSpreadStrictNull.ts, 17, 7)) +>sn : Symbol(sn, Decl(objectSpreadStrictNull.ts, 17, 41)) +>definiteBoolean : Symbol(definiteBoolean, Decl(objectSpreadStrictNull.ts, 0, 11)) +>undefinedString : Symbol(undefinedString, Decl(objectSpreadStrictNull.ts, 4, 36)) +>optionalNumber : Symbol(optionalNumber, Decl(objectSpreadStrictNull.ts, 3, 36)) } diff --git a/tests/baselines/reference/objectSpreadStrictNull.types b/tests/baselines/reference/objectSpreadStrictNull.types index c9ed742c6b626..f70f0a9cad26c 100644 --- a/tests/baselines/reference/objectSpreadStrictNull.types +++ b/tests/baselines/reference/objectSpreadStrictNull.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/spread/objectSpreadStrictNull.ts === - function f( >f : (definiteBoolean: { sn: boolean; }, definiteString: { sn: string; }, optionalString: { sn?: string | undefined; }, optionalNumber: { sn?: number | undefined; }, undefinedString: { sn: string | undefined; }, undefinedNumber: { sn: number | undefined; }) => void diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.js b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.js index 3ff5817692b09..ac227a091c775 100644 --- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.js +++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.js @@ -1,5 +1,4 @@ //// [objectTypeWithStringNamedNumericProperty.ts] - // string named numeric properties are legal and distinct when indexed by string values // indexed numerically the value is converted to a number // no errors expected below diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols index 480886711d501..9b5202d5dd435 100644 --- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols +++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/types/members/objectTypeWithStringNamedNumericProperty.ts === - // string named numeric properties are legal and distinct when indexed by string values // indexed numerically the value is converted to a number // no errors expected below @@ -25,93 +24,93 @@ class C { } var c: C; ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) >C : Symbol(C, Decl(objectTypeWithStringNamedNumericProperty.ts, 0, 0)) var r1 = c['0.1']; ->r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'0.1' : Symbol(C["0.1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 5, 9)) +>r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 77, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 107, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'0.1' : Symbol(C["0.1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 4, 9)) var r2 = c['.1']; ->r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'.1' : Symbol(C[".1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 16)) +>r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'.1' : Symbol(C[".1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 5, 16)) var r3 = c['1']; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'1' : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'1' : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r3 = c[1]; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r4 = c['1.']; ->r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'1.' : Symbol(C["1."], Decl(objectTypeWithStringNamedNumericProperty.ts, 8, 16)) +>r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'1.' : Symbol(C["1."], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 16)) var r3 = c[1.]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r5 = c['1..']; ->r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'1..' : Symbol(C["1.."], Decl(objectTypeWithStringNamedNumericProperty.ts, 9, 17)) +>r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'1..' : Symbol(C["1.."], Decl(objectTypeWithStringNamedNumericProperty.ts, 8, 17)) var r6 = c['1.0']; ->r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->'1.0' : Symbol(C["1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 10, 19)) +>r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>'1.0' : Symbol(C["1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 9, 19)) var r3 = c[1.0]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) // BUG 823822 var r7 = i[-1]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r7 = i[-1.0]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r8 = i["-1.0"]; ->r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 16)) +>r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 16)) var r9 = i["-1"]; ->r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 43, 19)) +>r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 19)) var r10 = i[0x1] ->r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r11 = i[-0x1] ->r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r12 = i[01] ->r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r13 = i[-01] ->r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 65, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 95, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 125, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) interface I { ->I : Symbol(I, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 16)) +>I : Symbol(I, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 16)) "0.1": void; ".1": Object; @@ -131,93 +130,93 @@ interface I { } var i: I; ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->I : Symbol(I, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 16)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>I : Symbol(I, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 16)) var r1 = i['0.1']; ->r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'0.1' : Symbol(I["0.1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 36, 13)) +>r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 77, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 107, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'0.1' : Symbol(I["0.1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 35, 13)) var r2 = i['.1']; ->r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'.1' : Symbol(I[".1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 16)) +>r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'.1' : Symbol(I[".1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 36, 16)) var r3 = i['1']; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'1' : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'1' : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r3 = c[1]; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r4 = i['1.']; ->r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'1.' : Symbol(I["1."], Decl(objectTypeWithStringNamedNumericProperty.ts, 39, 16)) +>r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'1.' : Symbol(I["1."], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 16)) var r3 = c[1.]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r5 = i['1..']; ->r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'1..' : Symbol(I["1.."], Decl(objectTypeWithStringNamedNumericProperty.ts, 40, 17)) +>r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'1..' : Symbol(I["1.."], Decl(objectTypeWithStringNamedNumericProperty.ts, 39, 17)) var r6 = i['1.0']; ->r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->'1.0' : Symbol(I["1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 19)) +>r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>'1.0' : Symbol(I["1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 40, 19)) var r3 = c[1.0]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) // BUG 823822 var r7 = i[-1]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r7 = i[-1.0]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r8 = i["-1.0"]; ->r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 16)) +>r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 16)) var r9 = i["-1"]; ->r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 43, 19)) +>r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 19)) var r10 = i[0x1] ->r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r11 = i[-0x1] ->r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r12 = i[01] ->r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r13 = i[-01] ->r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 65, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 95, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 125, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var a: { ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) "0.1": void; ".1": Object; @@ -237,89 +236,89 @@ var a: { } var r1 = a['0.1']; ->r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'0.1' : Symbol("0.1", Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 8)) +>r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 77, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 107, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'0.1' : Symbol("0.1", Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 8)) var r2 = a['.1']; ->r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'.1' : Symbol(".1", Decl(objectTypeWithStringNamedNumericProperty.ts, 68, 16)) +>r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'.1' : Symbol(".1", Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 16)) var r3 = a['1']; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'1' : Symbol("1", Decl(objectTypeWithStringNamedNumericProperty.ts, 69, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'1' : Symbol("1", Decl(objectTypeWithStringNamedNumericProperty.ts, 68, 17)) var r3 = c[1]; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r4 = a['1.']; ->r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'1.' : Symbol("1.", Decl(objectTypeWithStringNamedNumericProperty.ts, 70, 16)) +>r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'1.' : Symbol("1.", Decl(objectTypeWithStringNamedNumericProperty.ts, 69, 16)) var r3 = c[1.]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r5 = a['1..']; ->r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'1..' : Symbol("1..", Decl(objectTypeWithStringNamedNumericProperty.ts, 71, 17)) +>r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'1..' : Symbol("1..", Decl(objectTypeWithStringNamedNumericProperty.ts, 70, 17)) var r6 = a['1.0']; ->r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) ->a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 67, 3)) ->'1.0' : Symbol("1.0", Decl(objectTypeWithStringNamedNumericProperty.ts, 72, 19)) +>r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) +>a : Symbol(a, Decl(objectTypeWithStringNamedNumericProperty.ts, 66, 3)) +>'1.0' : Symbol("1.0", Decl(objectTypeWithStringNamedNumericProperty.ts, 71, 19)) var r3 = c[1.0]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) // BUG 823822 var r7 = i[-1]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r7 = i[-1.0]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r8 = i["-1.0"]; ->r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 16)) +>r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 16)) var r9 = i["-1"]; ->r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 43, 19)) +>r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 19)) var r10 = i[0x1] ->r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r11 = i[-0x1] ->r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r12 = i[01] ->r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r13 = i[-01] ->r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 65, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 95, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 125, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var b = { ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) "0.1": null, ".1": new Object(), @@ -338,84 +337,84 @@ var b = { }; var r1 = b['0.1']; ->r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'0.1' : Symbol("0.1", Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 9)) +>r1 : Symbol(r1, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 77, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 107, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'0.1' : Symbol("0.1", Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 9)) var r2 = b['.1']; ->r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'.1' : Symbol(".1", Decl(objectTypeWithStringNamedNumericProperty.ts, 98, 22)) +>r2 : Symbol(r2, Decl(objectTypeWithStringNamedNumericProperty.ts, 17, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 48, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 78, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 108, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'.1' : Symbol(".1", Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 22)) var r3 = b['1']; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'1' : Symbol("1", Decl(objectTypeWithStringNamedNumericProperty.ts, 99, 23)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'1' : Symbol("1", Decl(objectTypeWithStringNamedNumericProperty.ts, 98, 23)) var r3 = c[1]; ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r4 = b['1.']; ->r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'1.' : Symbol("1.", Decl(objectTypeWithStringNamedNumericProperty.ts, 100, 11)) +>r4 : Symbol(r4, Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'1.' : Symbol("1.", Decl(objectTypeWithStringNamedNumericProperty.ts, 99, 11)) var r3 = c[1.]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1. : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) var r5 = b['1..']; ->r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'1..' : Symbol("1..", Decl(objectTypeWithStringNamedNumericProperty.ts, 101, 13)) +>r5 : Symbol(r5, Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'1..' : Symbol("1..", Decl(objectTypeWithStringNamedNumericProperty.ts, 100, 13)) var r6 = b['1.0']; ->r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) ->b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3)) ->'1.0' : Symbol("1.0", Decl(objectTypeWithStringNamedNumericProperty.ts, 102, 16)) +>r6 : Symbol(r6, Decl(objectTypeWithStringNamedNumericProperty.ts, 23, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 54, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 84, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 114, 3)) +>b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 96, 3)) +>'1.0' : Symbol("1.0", Decl(objectTypeWithStringNamedNumericProperty.ts, 101, 16)) var r3 = c[1.0]; // same as indexing by 1 when done numerically ->r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 20, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 22, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 25, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 51, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 53, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 56, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 81, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 83, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 86, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 111, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 113, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 116, 3)) ->c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 16, 3)) ->1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 7, 17)) +>r3 : Symbol(r3, Decl(objectTypeWithStringNamedNumericProperty.ts, 18, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 19, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 21, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 24, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 49, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 50, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 52, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 55, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 79, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 80, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 82, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 85, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 109, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 110, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 112, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 115, 3)) +>c : Symbol(c, Decl(objectTypeWithStringNamedNumericProperty.ts, 15, 3)) +>1.0 : Symbol(C["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 6, 17)) // BUG 823822 var r7 = i[-1]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r7 = i[-1.0]; ->r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r7 : Symbol(r7, Decl(objectTypeWithStringNamedNumericProperty.ts, 26, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 27, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 57, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 58, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 87, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 88, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 117, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 118, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r8 = i["-1.0"]; ->r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 16)) +>r8 : Symbol(r8, Decl(objectTypeWithStringNamedNumericProperty.ts, 28, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 59, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 89, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 119, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1.0" : Symbol(I["-1.0"], Decl(objectTypeWithStringNamedNumericProperty.ts, 41, 16)) var r9 = i["-1"]; ->r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 43, 19)) +>r9 : Symbol(r9, Decl(objectTypeWithStringNamedNumericProperty.ts, 29, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 60, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 90, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 120, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>"-1" : Symbol(I["-1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 42, 19)) var r10 = i[0x1] ->r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r10 : Symbol(r10, Decl(objectTypeWithStringNamedNumericProperty.ts, 30, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 61, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 91, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 121, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>0x1 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r11 = i[-0x1] ->r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r11 : Symbol(r11, Decl(objectTypeWithStringNamedNumericProperty.ts, 31, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 62, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 92, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 122, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) var r12 = i[01] ->r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) ->01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 38, 17)) +>r12 : Symbol(r12, Decl(objectTypeWithStringNamedNumericProperty.ts, 32, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 63, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 93, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 123, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) +>01 : Symbol(I["1"], Decl(objectTypeWithStringNamedNumericProperty.ts, 37, 17)) var r13 = i[-01] ->r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 34, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 65, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 95, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 125, 3)) ->i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 47, 3)) +>r13 : Symbol(r13, Decl(objectTypeWithStringNamedNumericProperty.ts, 33, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 64, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 94, 3), Decl(objectTypeWithStringNamedNumericProperty.ts, 124, 3)) +>i : Symbol(i, Decl(objectTypeWithStringNamedNumericProperty.ts, 46, 3)) diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types index 1f34c4fafacb3..98081e6ab6cfb 100644 --- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types +++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/members/objectTypeWithStringNamedNumericProperty.ts === - // string named numeric properties are legal and distinct when indexed by string values // indexed numerically the value is converted to a number // no errors expected below diff --git a/tests/baselines/reference/optionalBindingParameters1.errors.txt b/tests/baselines/reference/optionalBindingParameters1.errors.txt index 66256edf727d3..339f004298394 100644 --- a/tests/baselines/reference/optionalBindingParameters1.errors.txt +++ b/tests/baselines/reference/optionalBindingParameters1.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(2,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. -tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(8,5): error TS2345: Argument of type '[boolean, number, ""]' is not assignable to parameter of type '[string, number, boolean]'. +tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(1,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. +tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(7,5): error TS2345: Argument of type '[boolean, number, ""]' is not assignable to parameter of type '[string, number, boolean]'. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts (2 errors) ==== - function foo([x,y,z]?: [string, number, boolean]) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2463: A binding pattern parameter cannot be optional in an implementation signature. diff --git a/tests/baselines/reference/optionalBindingParameters1.js b/tests/baselines/reference/optionalBindingParameters1.js index 536cb1e567a43..9c6a5b3fddab0 100644 --- a/tests/baselines/reference/optionalBindingParameters1.js +++ b/tests/baselines/reference/optionalBindingParameters1.js @@ -1,5 +1,4 @@ //// [optionalBindingParameters1.ts] - function foo([x,y,z]?: [string, number, boolean]) { } diff --git a/tests/baselines/reference/optionalBindingParameters2.errors.txt b/tests/baselines/reference/optionalBindingParameters2.errors.txt index 34f36d32380fd..b7e9bb1c2da1a 100644 --- a/tests/baselines/reference/optionalBindingParameters2.errors.txt +++ b/tests/baselines/reference/optionalBindingParameters2.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(2,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. -tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(8,5): error TS2345: Argument of type '{ x: boolean; y: number; z: ""; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. +tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(1,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. +tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(7,5): error TS2345: Argument of type '{ x: boolean; y: number; z: ""; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. Types of property 'x' are incompatible. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts (2 errors) ==== - function foo({ x, y, z }?: { x: string; y: number; z: boolean }) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2463: A binding pattern parameter cannot be optional in an implementation signature. diff --git a/tests/baselines/reference/optionalBindingParameters2.js b/tests/baselines/reference/optionalBindingParameters2.js index 04e1138561a78..ed1a5961fe276 100644 --- a/tests/baselines/reference/optionalBindingParameters2.js +++ b/tests/baselines/reference/optionalBindingParameters2.js @@ -1,5 +1,4 @@ //// [optionalBindingParameters2.ts] - function foo({ x, y, z }?: { x: string; y: number; z: boolean }) { } diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt index 771ada1a4647d..d2be862f6eff7 100644 --- a/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt +++ b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts(9,5): error TS2345: Argument of type '[boolean, number, ""]' is not assignable to parameter of type '[string, number, boolean]'. +tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts(8,5): error TS2345: Argument of type '[boolean, number, ""]' is not assignable to parameter of type '[string, number, boolean]'. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts (1 errors) ==== - function foo([x, y, z] ?: [string, number, boolean]); function foo(...rest: any[]) { diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads1.js b/tests/baselines/reference/optionalBindingParametersInOverloads1.js index 9fd64d0da9e72..05ad934c260bc 100644 --- a/tests/baselines/reference/optionalBindingParametersInOverloads1.js +++ b/tests/baselines/reference/optionalBindingParametersInOverloads1.js @@ -1,5 +1,4 @@ //// [optionalBindingParametersInOverloads1.ts] - function foo([x, y, z] ?: [string, number, boolean]); function foo(...rest: any[]) { diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt b/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt index e2546aff7243e..ccbdfce2fddec 100644 --- a/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt +++ b/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts(9,5): error TS2345: Argument of type '{ x: boolean; y: number; z: ""; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. +tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts(8,5): error TS2345: Argument of type '{ x: boolean; y: number; z: ""; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. Types of property 'x' are incompatible. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts (1 errors) ==== - function foo({ x, y, z }?: { x: string; y: number; z: boolean }); function foo(...rest: any[]) { diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads2.js b/tests/baselines/reference/optionalBindingParametersInOverloads2.js index 033d81993f5e9..956441b89e817 100644 --- a/tests/baselines/reference/optionalBindingParametersInOverloads2.js +++ b/tests/baselines/reference/optionalBindingParametersInOverloads2.js @@ -1,5 +1,4 @@ //// [optionalBindingParametersInOverloads2.ts] - function foo({ x, y, z }?: { x: string; y: number; z: boolean }); function foo(...rest: any[]) { diff --git a/tests/baselines/reference/optionalMethods.js b/tests/baselines/reference/optionalMethods.js index a3685175f6675..d219466c5623c 100644 --- a/tests/baselines/reference/optionalMethods.js +++ b/tests/baselines/reference/optionalMethods.js @@ -1,5 +1,4 @@ //// [optionalMethods.ts] - interface Foo { a: number; b?: number; diff --git a/tests/baselines/reference/optionalMethods.symbols b/tests/baselines/reference/optionalMethods.symbols index 55c5ec958da97..9e9d3a0a3328c 100644 --- a/tests/baselines/reference/optionalMethods.symbols +++ b/tests/baselines/reference/optionalMethods.symbols @@ -1,203 +1,202 @@ === tests/cases/conformance/types/namedTypes/optionalMethods.ts === - interface Foo { >Foo : Symbol(Foo, Decl(optionalMethods.ts, 0, 0)) a: number; ->a : Symbol(Foo.a, Decl(optionalMethods.ts, 1, 15)) +>a : Symbol(Foo.a, Decl(optionalMethods.ts, 0, 15)) b?: number; ->b : Symbol(Foo.b, Decl(optionalMethods.ts, 2, 14)) +>b : Symbol(Foo.b, Decl(optionalMethods.ts, 1, 14)) f(): number; ->f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) +>f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) g?(): number; ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) } function test1(x: Foo) { ->test1 : Symbol(test1, Decl(optionalMethods.ts, 6, 1)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) +>test1 : Symbol(test1, Decl(optionalMethods.ts, 5, 1)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) >Foo : Symbol(Foo, Decl(optionalMethods.ts, 0, 0)) x.a; ->x.a : Symbol(Foo.a, Decl(optionalMethods.ts, 1, 15)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->a : Symbol(Foo.a, Decl(optionalMethods.ts, 1, 15)) +>x.a : Symbol(Foo.a, Decl(optionalMethods.ts, 0, 15)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>a : Symbol(Foo.a, Decl(optionalMethods.ts, 0, 15)) x.b; ->x.b : Symbol(Foo.b, Decl(optionalMethods.ts, 2, 14)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->b : Symbol(Foo.b, Decl(optionalMethods.ts, 2, 14)) +>x.b : Symbol(Foo.b, Decl(optionalMethods.ts, 1, 14)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>b : Symbol(Foo.b, Decl(optionalMethods.ts, 1, 14)) x.f; ->x.f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) +>x.f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) x.g; ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) let f1 = x.f(); ->f1 : Symbol(f1, Decl(optionalMethods.ts, 13, 7)) ->x.f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->f : Symbol(Foo.f, Decl(optionalMethods.ts, 3, 15)) +>f1 : Symbol(f1, Decl(optionalMethods.ts, 12, 7)) +>x.f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>f : Symbol(Foo.f, Decl(optionalMethods.ts, 2, 15)) let g1 = x.g && x.g(); ->g1 : Symbol(g1, Decl(optionalMethods.ts, 14, 7)) ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) +>g1 : Symbol(g1, Decl(optionalMethods.ts, 13, 7)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) let g2 = x.g ? x.g() : 0; ->g2 : Symbol(g2, Decl(optionalMethods.ts, 15, 7)) ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 8, 15)) ->g : Symbol(Foo.g, Decl(optionalMethods.ts, 4, 16)) +>g2 : Symbol(g2, Decl(optionalMethods.ts, 14, 7)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x.g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 7, 15)) +>g : Symbol(Foo.g, Decl(optionalMethods.ts, 3, 16)) } class Bar { ->Bar : Symbol(Bar, Decl(optionalMethods.ts, 16, 1)) +>Bar : Symbol(Bar, Decl(optionalMethods.ts, 15, 1)) a: number; ->a : Symbol(Bar.a, Decl(optionalMethods.ts, 18, 11)) +>a : Symbol(Bar.a, Decl(optionalMethods.ts, 17, 11)) b?: number; ->b : Symbol(Bar.b, Decl(optionalMethods.ts, 19, 14)) +>b : Symbol(Bar.b, Decl(optionalMethods.ts, 18, 14)) c? = 2; ->c : Symbol(Bar.c, Decl(optionalMethods.ts, 20, 15)) +>c : Symbol(Bar.c, Decl(optionalMethods.ts, 19, 15)) constructor(public d?: number, public e = 10) {} ->d : Symbol(Bar.d, Decl(optionalMethods.ts, 22, 16)) ->e : Symbol(Bar.e, Decl(optionalMethods.ts, 22, 34)) +>d : Symbol(Bar.d, Decl(optionalMethods.ts, 21, 16)) +>e : Symbol(Bar.e, Decl(optionalMethods.ts, 21, 34)) f() { ->f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) +>f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) return 1; } g?(): number; // Body of optional method can be omitted ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) h?() { ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) return 2; } } function test2(x: Bar) { ->test2 : Symbol(test2, Decl(optionalMethods.ts, 30, 1)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->Bar : Symbol(Bar, Decl(optionalMethods.ts, 16, 1)) +>test2 : Symbol(test2, Decl(optionalMethods.ts, 29, 1)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>Bar : Symbol(Bar, Decl(optionalMethods.ts, 15, 1)) x.a; ->x.a : Symbol(Bar.a, Decl(optionalMethods.ts, 18, 11)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->a : Symbol(Bar.a, Decl(optionalMethods.ts, 18, 11)) +>x.a : Symbol(Bar.a, Decl(optionalMethods.ts, 17, 11)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>a : Symbol(Bar.a, Decl(optionalMethods.ts, 17, 11)) x.b; ->x.b : Symbol(Bar.b, Decl(optionalMethods.ts, 19, 14)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->b : Symbol(Bar.b, Decl(optionalMethods.ts, 19, 14)) +>x.b : Symbol(Bar.b, Decl(optionalMethods.ts, 18, 14)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>b : Symbol(Bar.b, Decl(optionalMethods.ts, 18, 14)) x.c; ->x.c : Symbol(Bar.c, Decl(optionalMethods.ts, 20, 15)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->c : Symbol(Bar.c, Decl(optionalMethods.ts, 20, 15)) +>x.c : Symbol(Bar.c, Decl(optionalMethods.ts, 19, 15)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>c : Symbol(Bar.c, Decl(optionalMethods.ts, 19, 15)) x.d; ->x.d : Symbol(Bar.d, Decl(optionalMethods.ts, 22, 16)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->d : Symbol(Bar.d, Decl(optionalMethods.ts, 22, 16)) +>x.d : Symbol(Bar.d, Decl(optionalMethods.ts, 21, 16)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>d : Symbol(Bar.d, Decl(optionalMethods.ts, 21, 16)) x.e; ->x.e : Symbol(Bar.e, Decl(optionalMethods.ts, 22, 34)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->e : Symbol(Bar.e, Decl(optionalMethods.ts, 22, 34)) +>x.e : Symbol(Bar.e, Decl(optionalMethods.ts, 21, 34)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>e : Symbol(Bar.e, Decl(optionalMethods.ts, 21, 34)) x.f; ->x.f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) +>x.f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) x.g; ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) let f1 = x.f(); ->f1 : Symbol(f1, Decl(optionalMethods.ts, 40, 7)) ->x.f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->f : Symbol(Bar.f, Decl(optionalMethods.ts, 22, 52)) +>f1 : Symbol(f1, Decl(optionalMethods.ts, 39, 7)) +>x.f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>f : Symbol(Bar.f, Decl(optionalMethods.ts, 21, 52)) let g1 = x.g && x.g(); ->g1 : Symbol(g1, Decl(optionalMethods.ts, 41, 7)) ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) +>g1 : Symbol(g1, Decl(optionalMethods.ts, 40, 7)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) let g2 = x.g ? x.g() : 0; ->g2 : Symbol(g2, Decl(optionalMethods.ts, 42, 7)) ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->g : Symbol(Bar.g, Decl(optionalMethods.ts, 25, 5)) +>g2 : Symbol(g2, Decl(optionalMethods.ts, 41, 7)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x.g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>g : Symbol(Bar.g, Decl(optionalMethods.ts, 24, 5)) let h1 = x.h && x.h(); ->h1 : Symbol(h1, Decl(optionalMethods.ts, 43, 7)) ->x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) +>h1 : Symbol(h1, Decl(optionalMethods.ts, 42, 7)) +>x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) let h2 = x.h ? x.h() : 0; ->h2 : Symbol(h2, Decl(optionalMethods.ts, 44, 7)) ->x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) ->x : Symbol(x, Decl(optionalMethods.ts, 32, 15)) ->h : Symbol(Bar.h, Decl(optionalMethods.ts, 26, 17)) +>h2 : Symbol(h2, Decl(optionalMethods.ts, 43, 7)) +>x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x.h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) +>x : Symbol(x, Decl(optionalMethods.ts, 31, 15)) +>h : Symbol(Bar.h, Decl(optionalMethods.ts, 25, 17)) } class Base { ->Base : Symbol(Base, Decl(optionalMethods.ts, 45, 1)) +>Base : Symbol(Base, Decl(optionalMethods.ts, 44, 1)) a?: number; ->a : Symbol(Base.a, Decl(optionalMethods.ts, 47, 12)) +>a : Symbol(Base.a, Decl(optionalMethods.ts, 46, 12)) f?(): number; ->f : Symbol(Base.f, Decl(optionalMethods.ts, 48, 15)) +>f : Symbol(Base.f, Decl(optionalMethods.ts, 47, 15)) } class Derived extends Base { ->Derived : Symbol(Derived, Decl(optionalMethods.ts, 50, 1)) ->Base : Symbol(Base, Decl(optionalMethods.ts, 45, 1)) +>Derived : Symbol(Derived, Decl(optionalMethods.ts, 49, 1)) +>Base : Symbol(Base, Decl(optionalMethods.ts, 44, 1)) a = 1; ->a : Symbol(Derived.a, Decl(optionalMethods.ts, 52, 28)) +>a : Symbol(Derived.a, Decl(optionalMethods.ts, 51, 28)) f(): number { return 1; } ->f : Symbol(Derived.f, Decl(optionalMethods.ts, 53, 10)) +>f : Symbol(Derived.f, Decl(optionalMethods.ts, 52, 10)) } diff --git a/tests/baselines/reference/optionalMethods.types b/tests/baselines/reference/optionalMethods.types index cf545eda50997..735ce95fee469 100644 --- a/tests/baselines/reference/optionalMethods.types +++ b/tests/baselines/reference/optionalMethods.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/namedTypes/optionalMethods.ts === - interface Foo { >Foo : Foo diff --git a/tests/baselines/reference/optionalParameterProperty.errors.txt b/tests/baselines/reference/optionalParameterProperty.errors.txt index d585ff6964dbc..c82dbd4ec9c2a 100644 --- a/tests/baselines/reference/optionalParameterProperty.errors.txt +++ b/tests/baselines/reference/optionalParameterProperty.errors.txt @@ -1,11 +1,10 @@ -tests/cases/compiler/optionalParameterProperty.ts(6,7): error TS2415: Class 'D' incorrectly extends base class 'C'. +tests/cases/compiler/optionalParameterProperty.ts(5,7): error TS2415: Class 'D' incorrectly extends base class 'C'. Types of property 'p' are incompatible. Type 'number | undefined' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. ==== tests/cases/compiler/optionalParameterProperty.ts (1 errors) ==== - class C { p: number; } diff --git a/tests/baselines/reference/optionalParameterProperty.js b/tests/baselines/reference/optionalParameterProperty.js index fc288d0976723..da0d2286714d4 100644 --- a/tests/baselines/reference/optionalParameterProperty.js +++ b/tests/baselines/reference/optionalParameterProperty.js @@ -1,5 +1,4 @@ //// [optionalParameterProperty.ts] - class C { p: number; } diff --git a/tests/baselines/reference/optionalParamterAndVariableDeclaration2.errors.txt b/tests/baselines/reference/optionalParamterAndVariableDeclaration2.errors.txt index 0d3093275317d..982318d2f2548 100644 --- a/tests/baselines/reference/optionalParamterAndVariableDeclaration2.errors.txt +++ b/tests/baselines/reference/optionalParamterAndVariableDeclaration2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/optionalParamterAndVariableDeclaration2.ts(4,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'options' must be of type 'number | undefined', but here has type 'number'. +tests/cases/compiler/optionalParamterAndVariableDeclaration2.ts(3,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'options' must be of type 'number | undefined', but here has type 'number'. ==== tests/cases/compiler/optionalParamterAndVariableDeclaration2.ts (1 errors) ==== - class C { constructor(options?: number) { var options = (options || 0); diff --git a/tests/baselines/reference/optionalParamterAndVariableDeclaration2.js b/tests/baselines/reference/optionalParamterAndVariableDeclaration2.js index a4ffc9f382d9d..0de4ac00a660e 100644 --- a/tests/baselines/reference/optionalParamterAndVariableDeclaration2.js +++ b/tests/baselines/reference/optionalParamterAndVariableDeclaration2.js @@ -1,5 +1,4 @@ //// [optionalParamterAndVariableDeclaration2.ts] - class C { constructor(options?: number) { var options = (options || 0); diff --git a/tests/baselines/reference/optionalProperties01.js b/tests/baselines/reference/optionalProperties01.js index a614b9e7e37c1..75ad84fb24ec5 100644 --- a/tests/baselines/reference/optionalProperties01.js +++ b/tests/baselines/reference/optionalProperties01.js @@ -1,5 +1,4 @@ //// [optionalProperties01.ts] - interface Foo { required1: string; required2: string; diff --git a/tests/baselines/reference/optionalProperties01.symbols b/tests/baselines/reference/optionalProperties01.symbols index 95c53626f6e85..57f3161c2be98 100644 --- a/tests/baselines/reference/optionalProperties01.symbols +++ b/tests/baselines/reference/optionalProperties01.symbols @@ -1,26 +1,25 @@ === tests/cases/conformance/types/typeRelationships/comparable/optionalProperties01.ts === - interface Foo { >Foo : Symbol(Foo, Decl(optionalProperties01.ts, 0, 0)) required1: string; ->required1 : Symbol(Foo.required1, Decl(optionalProperties01.ts, 1, 15)) +>required1 : Symbol(Foo.required1, Decl(optionalProperties01.ts, 0, 15)) required2: string; ->required2 : Symbol(Foo.required2, Decl(optionalProperties01.ts, 2, 20)) +>required2 : Symbol(Foo.required2, Decl(optionalProperties01.ts, 1, 20)) optional?: string; ->optional : Symbol(Foo.optional, Decl(optionalProperties01.ts, 3, 20)) +>optional : Symbol(Foo.optional, Decl(optionalProperties01.ts, 2, 20)) } const foo1 = { required1: "hello" } as Foo; ->foo1 : Symbol(foo1, Decl(optionalProperties01.ts, 7, 5)) ->required1 : Symbol(required1, Decl(optionalProperties01.ts, 7, 14)) +>foo1 : Symbol(foo1, Decl(optionalProperties01.ts, 6, 5)) +>required1 : Symbol(required1, Decl(optionalProperties01.ts, 6, 14)) >Foo : Symbol(Foo, Decl(optionalProperties01.ts, 0, 0)) const foo2 = { required1: "hello", optional: "bar" } as Foo; ->foo2 : Symbol(foo2, Decl(optionalProperties01.ts, 8, 5)) ->required1 : Symbol(required1, Decl(optionalProperties01.ts, 8, 14)) ->optional : Symbol(optional, Decl(optionalProperties01.ts, 8, 34)) +>foo2 : Symbol(foo2, Decl(optionalProperties01.ts, 7, 5)) +>required1 : Symbol(required1, Decl(optionalProperties01.ts, 7, 14)) +>optional : Symbol(optional, Decl(optionalProperties01.ts, 7, 34)) >Foo : Symbol(Foo, Decl(optionalProperties01.ts, 0, 0)) diff --git a/tests/baselines/reference/optionalProperties01.types b/tests/baselines/reference/optionalProperties01.types index 20d16d4071e69..b60d87f07becb 100644 --- a/tests/baselines/reference/optionalProperties01.types +++ b/tests/baselines/reference/optionalProperties01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/comparable/optionalProperties01.ts === - interface Foo { >Foo : Foo diff --git a/tests/baselines/reference/optionalProperties02.js b/tests/baselines/reference/optionalProperties02.js index f632c5d67a8ed..99e08174cd4f6 100644 --- a/tests/baselines/reference/optionalProperties02.js +++ b/tests/baselines/reference/optionalProperties02.js @@ -1,5 +1,4 @@ //// [optionalProperties02.ts] - interface Foo { a?: string; b: string; diff --git a/tests/baselines/reference/optionalProperties02.symbols b/tests/baselines/reference/optionalProperties02.symbols index b88f9ad742982..3c431178c0c38 100644 --- a/tests/baselines/reference/optionalProperties02.symbols +++ b/tests/baselines/reference/optionalProperties02.symbols @@ -1,17 +1,16 @@ === tests/cases/conformance/types/typeRelationships/comparable/optionalProperties02.ts === - interface Foo { >Foo : Symbol(Foo, Decl(optionalProperties02.ts, 0, 0)) a?: string; ->a : Symbol(Foo.a, Decl(optionalProperties02.ts, 1, 15)) +>a : Symbol(Foo.a, Decl(optionalProperties02.ts, 0, 15)) b: string; ->b : Symbol(Foo.b, Decl(optionalProperties02.ts, 2, 15)) +>b : Symbol(Foo.b, Decl(optionalProperties02.ts, 1, 15)) } { a: undefined }; >Foo : Symbol(Foo, Decl(optionalProperties02.ts, 0, 0)) ->a : Symbol(a, Decl(optionalProperties02.ts, 6, 6)) +>a : Symbol(a, Decl(optionalProperties02.ts, 5, 6)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/optionalProperties02.types b/tests/baselines/reference/optionalProperties02.types index 05e979b397288..afb2e8ef41bad 100644 --- a/tests/baselines/reference/optionalProperties02.types +++ b/tests/baselines/reference/optionalProperties02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/comparable/optionalProperties02.ts === - interface Foo { >Foo : Foo diff --git a/tests/baselines/reference/optionsInlineSourceMapMapRoot.errors.txt b/tests/baselines/reference/optionsInlineSourceMapMapRoot.errors.txt index a9efb0e297179..77a221a8cbbd7 100644 --- a/tests/baselines/reference/optionsInlineSourceMapMapRoot.errors.txt +++ b/tests/baselines/reference/optionsInlineSourceMapMapRoot.errors.txt @@ -5,5 +5,4 @@ error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap' !!! error TS5052: Option 'mapRoot' cannot be specified without specifying option 'sourceMap'. !!! error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'. ==== tests/cases/compiler/optionsInlineSourceMapMapRoot.ts (0 errors) ==== - var a = 10; \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapMapRoot.js b/tests/baselines/reference/optionsInlineSourceMapMapRoot.js index c165c49ec2947..f169725529310 100644 --- a/tests/baselines/reference/optionsInlineSourceMapMapRoot.js +++ b/tests/baselines/reference/optionsInlineSourceMapMapRoot.js @@ -1,7 +1,6 @@ //// [optionsInlineSourceMapMapRoot.ts] - var a = 10; //// [optionsInlineSourceMapMapRoot.js] var a = 10; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapMapRoot.sourcemap.txt b/tests/baselines/reference/optionsInlineSourceMapMapRoot.sourcemap.txt index 66d860c22b2b0..20ebfade939e3 100644 --- a/tests/baselines/reference/optionsInlineSourceMapMapRoot.sourcemap.txt +++ b/tests/baselines/reference/optionsInlineSourceMapMapRoot.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: optionsInlineSourceMapMapRoot.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== sourceRoot: sources: ../optionsInlineSourceMapMapRoot.ts =================================================================== @@ -16,18 +16,17 @@ sourceFile:../optionsInlineSourceMapMapRoot.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.js b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.js index 748fae7320ccb..2570ef236aa60 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.js +++ b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.js @@ -1,7 +1,6 @@ //// [optionsInlineSourceMapSourceRoot.ts] - var a = 10; //// [optionsInlineSourceMapSourceRoot.js] var a = 10; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.sourcemap.txt b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.sourcemap.txt index 6178766b21c95..ceaa1501a5944 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.sourcemap.txt +++ b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: optionsInlineSourceMapSourceRoot.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== sourceRoot: local/ sources: optionsInlineSourceMapSourceRoot.ts =================================================================== @@ -16,18 +16,17 @@ sourceFile:optionsInlineSourceMapSourceRoot.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.symbols b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.symbols index cf8c0826d8ee0..ae41cf7e2ce9f 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.symbols +++ b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsInlineSourceMapSourceRoot.ts === - var a = 10; ->a : Symbol(a, Decl(optionsInlineSourceMapSourceRoot.ts, 1, 3)) +>a : Symbol(a, Decl(optionsInlineSourceMapSourceRoot.ts, 0, 3)) diff --git a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.types b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.types index a1a47c3f97555..0d7d0cf426058 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourceRoot.types +++ b/tests/baselines/reference/optionsInlineSourceMapSourceRoot.types @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsInlineSourceMapSourceRoot.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/optionsInlineSourceMapSourcemap.errors.txt b/tests/baselines/reference/optionsInlineSourceMapSourcemap.errors.txt index e91781ccd776a..350de19622a15 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourcemap.errors.txt +++ b/tests/baselines/reference/optionsInlineSourceMapSourcemap.errors.txt @@ -3,5 +3,4 @@ error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMa !!! error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'. ==== tests/cases/compiler/optionsInlineSourceMapSourcemap.ts (0 errors) ==== - var a = 10; \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourcemap.js b/tests/baselines/reference/optionsInlineSourceMapSourcemap.js index 96d468d27daf3..99345352a0744 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourcemap.js +++ b/tests/baselines/reference/optionsInlineSourceMapSourcemap.js @@ -1,7 +1,6 @@ //// [optionsInlineSourceMapSourcemap.ts] - var a = 10; //// [optionsInlineSourceMapSourcemap.js] var a = 10; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= \ No newline at end of file diff --git a/tests/baselines/reference/optionsInlineSourceMapSourcemap.sourcemap.txt b/tests/baselines/reference/optionsInlineSourceMapSourcemap.sourcemap.txt index 6ca02eb22d12f..b015ec502f1d5 100644 --- a/tests/baselines/reference/optionsInlineSourceMapSourcemap.sourcemap.txt +++ b/tests/baselines/reference/optionsInlineSourceMapSourcemap.sourcemap.txt @@ -1,6 +1,6 @@ =================================================================== JsFile: optionsInlineSourceMapSourcemap.js -mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= +mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= sourceRoot: sources: optionsInlineSourceMapSourcemap.ts =================================================================== @@ -16,18 +16,17 @@ sourceFile:optionsInlineSourceMapSourcemap.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- ->>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= \ No newline at end of file +>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0= \ No newline at end of file diff --git a/tests/baselines/reference/optionsOutAndNoModuleGen.errors.txt b/tests/baselines/reference/optionsOutAndNoModuleGen.errors.txt index 9fa887c53b31e..f68665e0d7d5b 100644 --- a/tests/baselines/reference/optionsOutAndNoModuleGen.errors.txt +++ b/tests/baselines/reference/optionsOutAndNoModuleGen.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/optionsOutAndNoModuleGen.ts(2,1): error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. +tests/cases/compiler/optionsOutAndNoModuleGen.ts(1,1): error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. ==== tests/cases/compiler/optionsOutAndNoModuleGen.ts (1 errors) ==== - export var x = 10; ~~~~~~~~~~~~~~~~~~ !!! error TS6131: Cannot compile modules using option 'out' unless the '--module' flag is 'amd' or 'system'. \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.js b/tests/baselines/reference/optionsSourcemapInlineSources.js index 029575ab99259..a739c3a55e96b 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.js +++ b/tests/baselines/reference/optionsSourcemapInlineSources.js @@ -1,5 +1,4 @@ //// [optionsSourcemapInlineSources.ts] - var a = 10; //// [optionsSourcemapInlineSources.js] diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.js.map b/tests/baselines/reference/optionsSourcemapInlineSources.js.map index 2be063325733a..5f63b4b897f11 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.js.map +++ b/tests/baselines/reference/optionsSourcemapInlineSources.js.map @@ -1,2 +1,2 @@ //// [optionsSourcemapInlineSources.js.map] -{"version":3,"file":"optionsSourcemapInlineSources.js","sourceRoot":"","sources":["optionsSourcemapInlineSources.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["\nvar a = 10;"]} \ No newline at end of file +{"version":3,"file":"optionsSourcemapInlineSources.js","sourceRoot":"","sources":["optionsSourcemapInlineSources.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["var a = 10;"]} \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.sourcemap.txt b/tests/baselines/reference/optionsSourcemapInlineSources.sourcemap.txt index 79119d8c68714..1d12bed1f40cd 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.sourcemap.txt +++ b/tests/baselines/reference/optionsSourcemapInlineSources.sourcemap.txt @@ -3,7 +3,7 @@ JsFile: optionsSourcemapInlineSources.js mapUrl: optionsSourcemapInlineSources.js.map sourceRoot: sources: optionsSourcemapInlineSources.ts -sourcesContent: ["\nvar a = 10;"] +sourcesContent: ["var a = 10;"] =================================================================== ------------------------------------------------------------------- emittedFile:tests/cases/compiler/optionsSourcemapInlineSources.js @@ -17,18 +17,17 @@ sourceFile:optionsSourcemapInlineSources.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- >>>//# sourceMappingURL=optionsSourcemapInlineSources.js.map \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.symbols b/tests/baselines/reference/optionsSourcemapInlineSources.symbols index 50649b86a0ddc..db0a395bf52b9 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.symbols +++ b/tests/baselines/reference/optionsSourcemapInlineSources.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSources.ts === - var a = 10; ->a : Symbol(a, Decl(optionsSourcemapInlineSources.ts, 1, 3)) +>a : Symbol(a, Decl(optionsSourcemapInlineSources.ts, 0, 3)) diff --git a/tests/baselines/reference/optionsSourcemapInlineSources.types b/tests/baselines/reference/optionsSourcemapInlineSources.types index 1c9865777bbf8..410ab7729cce3 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSources.types +++ b/tests/baselines/reference/optionsSourcemapInlineSources.types @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSources.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js index f7100140850f6..37bf30053e21a 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js @@ -1,5 +1,4 @@ //// [optionsSourcemapInlineSourcesMapRoot.ts] - var a = 10; //// [optionsSourcemapInlineSourcesMapRoot.js] diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js.map b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js.map index e99843b577f73..9b9206afe1179 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js.map +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js.map @@ -1,2 +1,2 @@ //// [optionsSourcemapInlineSourcesMapRoot.js.map] -{"version":3,"file":"optionsSourcemapInlineSourcesMapRoot.js","sourceRoot":"","sources":["../optionsSourcemapInlineSourcesMapRoot.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["\nvar a = 10;"]} \ No newline at end of file +{"version":3,"file":"optionsSourcemapInlineSourcesMapRoot.js","sourceRoot":"","sources":["../optionsSourcemapInlineSourcesMapRoot.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["var a = 10;"]} \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.sourcemap.txt b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.sourcemap.txt index a00040a9c93c4..f3771739eabc6 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.sourcemap.txt +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.sourcemap.txt @@ -3,7 +3,7 @@ JsFile: optionsSourcemapInlineSourcesMapRoot.js mapUrl: local/optionsSourcemapInlineSourcesMapRoot.js.map sourceRoot: sources: ../optionsSourcemapInlineSourcesMapRoot.ts -sourcesContent: ["\nvar a = 10;"] +sourcesContent: ["var a = 10;"] =================================================================== ------------------------------------------------------------------- emittedFile:tests/cases/compiler/optionsSourcemapInlineSourcesMapRoot.js @@ -17,18 +17,17 @@ sourceFile:../optionsSourcemapInlineSourcesMapRoot.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- >>>//# sourceMappingURL=local/optionsSourcemapInlineSourcesMapRoot.js.map \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.symbols b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.symbols index 57833abe2eeba..543c434cc23ab 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.symbols +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSourcesMapRoot.ts === - var a = 10; ->a : Symbol(a, Decl(optionsSourcemapInlineSourcesMapRoot.ts, 1, 3)) +>a : Symbol(a, Decl(optionsSourcemapInlineSourcesMapRoot.ts, 0, 3)) diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.types b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.types index cfe881d34f5bc..ccc9ac38cae33 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.types +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.types @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSourcesMapRoot.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js index 948d6536f46a7..c793cefa47395 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js @@ -1,5 +1,4 @@ //// [optionsSourcemapInlineSourcesSourceRoot.ts] - var a = 10; //// [optionsSourcemapInlineSourcesSourceRoot.js] diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js.map b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js.map index ad373e11aab4e..9dd850b188d4a 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js.map +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js.map @@ -1,2 +1,2 @@ //// [optionsSourcemapInlineSourcesSourceRoot.js.map] -{"version":3,"file":"optionsSourcemapInlineSourcesSourceRoot.js","sourceRoot":"local/","sources":["optionsSourcemapInlineSourcesSourceRoot.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["\nvar a = 10;"]} \ No newline at end of file +{"version":3,"file":"optionsSourcemapInlineSourcesSourceRoot.js","sourceRoot":"local/","sources":["optionsSourcemapInlineSourcesSourceRoot.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["var a = 10;"]} \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.sourcemap.txt b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.sourcemap.txt index 55102f5c1cdfa..6f00f1c51b84c 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.sourcemap.txt +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.sourcemap.txt @@ -3,7 +3,7 @@ JsFile: optionsSourcemapInlineSourcesSourceRoot.js mapUrl: optionsSourcemapInlineSourcesSourceRoot.js.map sourceRoot: local/ sources: optionsSourcemapInlineSourcesSourceRoot.ts -sourcesContent: ["\nvar a = 10;"] +sourcesContent: ["var a = 10;"] =================================================================== ------------------------------------------------------------------- emittedFile:tests/cases/compiler/optionsSourcemapInlineSourcesSourceRoot.js @@ -17,18 +17,17 @@ sourceFile:optionsSourcemapInlineSourcesSourceRoot.ts 5 > ^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > a 4 > = 5 > 10 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +6 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) --- >>>//# sourceMappingURL=optionsSourcemapInlineSourcesSourceRoot.js.map \ No newline at end of file diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.symbols b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.symbols index 76f2dc5fdc426..43c57f0ff5ec0 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.symbols +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSourcesSourceRoot.ts === - var a = 10; ->a : Symbol(a, Decl(optionsSourcemapInlineSourcesSourceRoot.ts, 1, 3)) +>a : Symbol(a, Decl(optionsSourcemapInlineSourcesSourceRoot.ts, 0, 3)) diff --git a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.types b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.types index 02226ff945a8b..2a96fca313c18 100644 --- a/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.types +++ b/tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.types @@ -1,5 +1,4 @@ === tests/cases/compiler/optionsSourcemapInlineSourcesSourceRoot.ts === - var a = 10; >a : number >10 : 10 diff --git a/tests/baselines/reference/out-flag2.errors.txt b/tests/baselines/reference/out-flag2.errors.txt index ea6fed45bd0f7..7ee3abe4c1316 100644 --- a/tests/baselines/reference/out-flag2.errors.txt +++ b/tests/baselines/reference/out-flag2.errors.txt @@ -3,7 +3,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. ==== tests/cases/compiler/a.ts (0 errors) ==== - class A { } ==== tests/cases/compiler/b.ts (0 errors) ==== diff --git a/tests/baselines/reference/out-flag2.js b/tests/baselines/reference/out-flag2.js index 6d452daca6611..72d5b18eb54dd 100644 --- a/tests/baselines/reference/out-flag2.js +++ b/tests/baselines/reference/out-flag2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/out-flag2.ts] //// //// [a.ts] - class A { } //// [b.ts] diff --git a/tests/baselines/reference/out-flag2.js.map b/tests/baselines/reference/out-flag2.js.map index 2c2f112b23855..781afe86d7959 100644 --- a/tests/baselines/reference/out-flag2.js.map +++ b/tests/baselines/reference/out-flag2.js.map @@ -1,2 +1,2 @@ //// [c.js.map] -{"version":3,"file":"c.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AACA;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW;ACDX;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW"} \ No newline at end of file +{"version":3,"file":"c.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AAAA;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW;ACAX;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/out-flag2.sourcemap.txt b/tests/baselines/reference/out-flag2.sourcemap.txt index a4966bf9f823e..2867541c6ef34 100644 --- a/tests/baselines/reference/out-flag2.sourcemap.txt +++ b/tests/baselines/reference/out-flag2.sourcemap.txt @@ -11,15 +11,14 @@ sourceFile:tests/cases/compiler/a.ts >>>var A = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -27,16 +26,16 @@ sourceFile:tests/cases/compiler/a.ts 3 > ^^^^^^^^^-> 1->class A { 2 > } -1->Emitted(3, 5) Source(2, 11) + SourceIndex(0) -2 >Emitted(3, 6) Source(2, 12) + SourceIndex(0) +1->Emitted(3, 5) Source(1, 11) + SourceIndex(0) +2 >Emitted(3, 6) Source(1, 12) + SourceIndex(0) --- >>> return A; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(4, 5) Source(2, 11) + SourceIndex(0) -2 >Emitted(4, 13) Source(2, 12) + SourceIndex(0) +1->Emitted(4, 5) Source(1, 11) + SourceIndex(0) +2 >Emitted(4, 13) Source(1, 12) + SourceIndex(0) --- >>>}()); 1 > @@ -48,10 +47,10 @@ sourceFile:tests/cases/compiler/a.ts 2 >} 3 > 4 > class A { } -1 >Emitted(5, 1) Source(2, 11) + SourceIndex(0) -2 >Emitted(5, 2) Source(2, 12) + SourceIndex(0) -3 >Emitted(5, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(5, 6) Source(2, 12) + SourceIndex(0) +1 >Emitted(5, 1) Source(1, 11) + SourceIndex(0) +2 >Emitted(5, 2) Source(1, 12) + SourceIndex(0) +3 >Emitted(5, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(5, 6) Source(1, 12) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:c.js diff --git a/tests/baselines/reference/out-flag3.errors.txt b/tests/baselines/reference/out-flag3.errors.txt index c01cef151f3b0..cb2c73c79d817 100644 --- a/tests/baselines/reference/out-flag3.errors.txt +++ b/tests/baselines/reference/out-flag3.errors.txt @@ -5,7 +5,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --out. !!! error TS5053: Option 'out' cannot be specified with option 'outFile'. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --out. ==== tests/cases/compiler/a.ts (0 errors) ==== - // --out and --outFile error class A { } diff --git a/tests/baselines/reference/out-flag3.js b/tests/baselines/reference/out-flag3.js index 134bbfa9e0354..a2ad3272c0819 100644 --- a/tests/baselines/reference/out-flag3.js +++ b/tests/baselines/reference/out-flag3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/out-flag3.ts] //// //// [a.ts] - // --out and --outFile error class A { } diff --git a/tests/baselines/reference/out-flag3.js.map b/tests/baselines/reference/out-flag3.js.map index 5fb864821b7f2..b5c4727d95c2d 100644 --- a/tests/baselines/reference/out-flag3.js.map +++ b/tests/baselines/reference/out-flag3.js.map @@ -1,2 +1,2 @@ //// [c.js.map] -{"version":3,"file":"c.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AACA,4BAA4B;AAE5B;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW;ACHX;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW"} \ No newline at end of file +{"version":3,"file":"c.js","sourceRoot":"","sources":["tests/cases/compiler/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAE5B;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW;ACFX;IAAA;IAAU,CAAC;IAAD,QAAC;AAAD,CAAC,AAAX,IAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/out-flag3.sourcemap.txt b/tests/baselines/reference/out-flag3.sourcemap.txt index 8801fd1114323..c3787bbf59333 100644 --- a/tests/baselines/reference/out-flag3.sourcemap.txt +++ b/tests/baselines/reference/out-flag3.sourcemap.txt @@ -11,11 +11,10 @@ sourceFile:tests/cases/compiler/a.ts >>>// --out and --outFile error 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -1 > - > +1 > 2 >// --out and --outFile error -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 29) Source(2, 29) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 29) Source(1, 29) + SourceIndex(0) --- >>>var A = (function () { 1 > @@ -23,13 +22,13 @@ sourceFile:tests/cases/compiler/a.ts 1 > > > -1 >Emitted(2, 1) Source(4, 1) + SourceIndex(0) +1 >Emitted(2, 1) Source(3, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(3, 5) Source(4, 1) + SourceIndex(0) +1->Emitted(3, 5) Source(3, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -37,16 +36,16 @@ sourceFile:tests/cases/compiler/a.ts 3 > ^^^^^^^^^-> 1->class A { 2 > } -1->Emitted(4, 5) Source(4, 11) + SourceIndex(0) -2 >Emitted(4, 6) Source(4, 12) + SourceIndex(0) +1->Emitted(4, 5) Source(3, 11) + SourceIndex(0) +2 >Emitted(4, 6) Source(3, 12) + SourceIndex(0) --- >>> return A; 1->^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(5, 5) Source(4, 11) + SourceIndex(0) -2 >Emitted(5, 13) Source(4, 12) + SourceIndex(0) +1->Emitted(5, 5) Source(3, 11) + SourceIndex(0) +2 >Emitted(5, 13) Source(3, 12) + SourceIndex(0) --- >>>}()); 1 > @@ -58,10 +57,10 @@ sourceFile:tests/cases/compiler/a.ts 2 >} 3 > 4 > class A { } -1 >Emitted(6, 1) Source(4, 11) + SourceIndex(0) -2 >Emitted(6, 2) Source(4, 12) + SourceIndex(0) -3 >Emitted(6, 2) Source(4, 1) + SourceIndex(0) -4 >Emitted(6, 6) Source(4, 12) + SourceIndex(0) +1 >Emitted(6, 1) Source(3, 11) + SourceIndex(0) +2 >Emitted(6, 2) Source(3, 12) + SourceIndex(0) +3 >Emitted(6, 2) Source(3, 1) + SourceIndex(0) +4 >Emitted(6, 6) Source(3, 12) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:c.js diff --git a/tests/baselines/reference/outModuleConcatAmd.js b/tests/baselines/reference/outModuleConcatAmd.js index fd3a4003ddf24..12e5745a558a4 100644 --- a/tests/baselines/reference/outModuleConcatAmd.js +++ b/tests/baselines/reference/outModuleConcatAmd.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/outModuleConcatAmd.ts] //// //// [a.ts] - export class A { } //// [b.ts] diff --git a/tests/baselines/reference/outModuleConcatAmd.js.map b/tests/baselines/reference/outModuleConcatAmd.js.map index 0e1c7d24100f4..93aae7a2586fe 100644 --- a/tests/baselines/reference/outModuleConcatAmd.js.map +++ b/tests/baselines/reference/outModuleConcatAmd.js.map @@ -1,2 +1,2 @@ //// [all.js.map] -{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;;;;IACA;QAAA;QAAiB,CAAC;QAAD,QAAC;IAAD,CAAC,AAAlB,IAAkB;IAAL,cAAC;;;;;ICAd;QAAuB,qBAAC;QAAxB;;QAA2B,CAAC;QAAD,QAAC;IAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;IAAf,cAAC"} \ No newline at end of file +{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;;;;IAAA;QAAA;QAAiB,CAAC;QAAD,QAAC;IAAD,CAAC,AAAlB,IAAkB;IAAL,cAAC;;;;;ICCd;QAAuB,qBAAC;QAAxB;;QAA2B,CAAC;QAAD,QAAC;IAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;IAAf,cAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/outModuleConcatAmd.sourcemap.txt b/tests/baselines/reference/outModuleConcatAmd.sourcemap.txt index c18f4e4225237..c1c1f5b5420c5 100644 --- a/tests/baselines/reference/outModuleConcatAmd.sourcemap.txt +++ b/tests/baselines/reference/outModuleConcatAmd.sourcemap.txt @@ -24,15 +24,14 @@ sourceFile:tests/cases/compiler/ref/a.ts >>> var A = (function () { 1 >^^^^ 2 > ^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(14, 5) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(14, 5) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^^^^^ 2 > ^^-> 1-> -1->Emitted(15, 9) Source(2, 1) + SourceIndex(0) +1->Emitted(15, 9) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^^^^^ @@ -40,16 +39,16 @@ sourceFile:tests/cases/compiler/ref/a.ts 3 > ^^^^^^^^^-> 1->export class A { 2 > } -1->Emitted(16, 9) Source(2, 18) + SourceIndex(0) -2 >Emitted(16, 10) Source(2, 19) + SourceIndex(0) +1->Emitted(16, 9) Source(1, 18) + SourceIndex(0) +2 >Emitted(16, 10) Source(1, 19) + SourceIndex(0) --- >>> return A; 1->^^^^^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(17, 9) Source(2, 18) + SourceIndex(0) -2 >Emitted(17, 17) Source(2, 19) + SourceIndex(0) +1->Emitted(17, 9) Source(1, 18) + SourceIndex(0) +2 >Emitted(17, 17) Source(1, 19) + SourceIndex(0) --- >>> }()); 1 >^^^^ @@ -61,18 +60,18 @@ sourceFile:tests/cases/compiler/ref/a.ts 2 > } 3 > 4 > export class A { } -1 >Emitted(18, 5) Source(2, 18) + SourceIndex(0) -2 >Emitted(18, 6) Source(2, 19) + SourceIndex(0) -3 >Emitted(18, 6) Source(2, 1) + SourceIndex(0) -4 >Emitted(18, 10) Source(2, 19) + SourceIndex(0) +1 >Emitted(18, 5) Source(1, 18) + SourceIndex(0) +2 >Emitted(18, 6) Source(1, 19) + SourceIndex(0) +3 >Emitted(18, 6) Source(1, 1) + SourceIndex(0) +4 >Emitted(18, 10) Source(1, 19) + SourceIndex(0) --- >>> exports.A = A; 1->^^^^ 2 > ^^^^^^^^^^^^^^ 1-> 2 > A -1->Emitted(19, 5) Source(2, 14) + SourceIndex(0) -2 >Emitted(19, 19) Source(2, 15) + SourceIndex(0) +1->Emitted(19, 5) Source(1, 14) + SourceIndex(0) +2 >Emitted(19, 19) Source(1, 15) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:all.js diff --git a/tests/baselines/reference/outModuleConcatAmd.symbols b/tests/baselines/reference/outModuleConcatAmd.symbols index 349de40815a17..8f2ac39afbead 100644 --- a/tests/baselines/reference/outModuleConcatAmd.symbols +++ b/tests/baselines/reference/outModuleConcatAmd.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - export class A { } >A : Symbol(A, Decl(a.ts, 0, 0)) diff --git a/tests/baselines/reference/outModuleConcatAmd.types b/tests/baselines/reference/outModuleConcatAmd.types index 6e0d93988533a..f1f7a7f12f99c 100644 --- a/tests/baselines/reference/outModuleConcatAmd.types +++ b/tests/baselines/reference/outModuleConcatAmd.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - export class A { } >A : A diff --git a/tests/baselines/reference/outModuleConcatCommonjs.errors.txt b/tests/baselines/reference/outModuleConcatCommonjs.errors.txt index d1a2adbc93ffc..0121cd9b9dfeb 100644 --- a/tests/baselines/reference/outModuleConcatCommonjs.errors.txt +++ b/tests/baselines/reference/outModuleConcatCommonjs.errors.txt @@ -3,7 +3,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. ==== tests/cases/compiler/ref/a.ts (0 errors) ==== - // This should be an error export class A { } diff --git a/tests/baselines/reference/outModuleConcatES6.errors.txt b/tests/baselines/reference/outModuleConcatES6.errors.txt index d1a2adbc93ffc..0121cd9b9dfeb 100644 --- a/tests/baselines/reference/outModuleConcatES6.errors.txt +++ b/tests/baselines/reference/outModuleConcatES6.errors.txt @@ -3,7 +3,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. ==== tests/cases/compiler/ref/a.ts (0 errors) ==== - // This should be an error export class A { } diff --git a/tests/baselines/reference/outModuleConcatSystem.js b/tests/baselines/reference/outModuleConcatSystem.js index 1648748a168fb..9d2a406d118ce 100644 --- a/tests/baselines/reference/outModuleConcatSystem.js +++ b/tests/baselines/reference/outModuleConcatSystem.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/outModuleConcatSystem.ts] //// //// [a.ts] - export class A { } //// [b.ts] diff --git a/tests/baselines/reference/outModuleConcatSystem.js.map b/tests/baselines/reference/outModuleConcatSystem.js.map index 25b706844e242..e6f76f62f0553 100644 --- a/tests/baselines/reference/outModuleConcatSystem.js.map +++ b/tests/baselines/reference/outModuleConcatSystem.js.map @@ -1,2 +1,2 @@ //// [all.js.map] -{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;YACA;gBAAA;gBAAiB,CAAC;gBAAD,QAAC;YAAD,CAAC,AAAlB,IAAkB;;QAClB,CAAC;;;;;;;;;;;;;;YCDD;gBAAuB,qBAAC;gBAAxB;;gBAA2B,CAAC;gBAAD,QAAC;YAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;;QAAA,CAAC"} \ No newline at end of file +{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;YAAA;gBAAA;gBAAiB,CAAC;gBAAD,QAAC;YAAD,CAAC,AAAlB,IAAkB;;QAClB,CAAC;;;;;;;;;;;;;;YCAD;gBAAuB,qBAAC;gBAAxB;;gBAA2B,CAAC;gBAAD,QAAC;YAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;;QAAA,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/outModuleConcatSystem.sourcemap.txt b/tests/baselines/reference/outModuleConcatSystem.sourcemap.txt index a8dd4bb55e767..205f2cd7194bc 100644 --- a/tests/baselines/reference/outModuleConcatSystem.sourcemap.txt +++ b/tests/baselines/reference/outModuleConcatSystem.sourcemap.txt @@ -28,15 +28,14 @@ sourceFile:tests/cases/compiler/ref/a.ts >>> A = (function () { 1 >^^^^^^^^^^^^ 2 > ^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(18, 13) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(18, 13) Source(1, 1) + SourceIndex(0) --- >>> function A() { 1->^^^^^^^^^^^^^^^^ 2 > ^^-> 1-> -1->Emitted(19, 17) Source(2, 1) + SourceIndex(0) +1->Emitted(19, 17) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^^^^^^^^^^^^^ @@ -44,16 +43,16 @@ sourceFile:tests/cases/compiler/ref/a.ts 3 > ^^^^^^^^^-> 1->export class A { 2 > } -1->Emitted(20, 17) Source(2, 18) + SourceIndex(0) -2 >Emitted(20, 18) Source(2, 19) + SourceIndex(0) +1->Emitted(20, 17) Source(1, 18) + SourceIndex(0) +2 >Emitted(20, 18) Source(1, 19) + SourceIndex(0) --- >>> return A; 1->^^^^^^^^^^^^^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(21, 17) Source(2, 18) + SourceIndex(0) -2 >Emitted(21, 25) Source(2, 19) + SourceIndex(0) +1->Emitted(21, 17) Source(1, 18) + SourceIndex(0) +2 >Emitted(21, 25) Source(1, 19) + SourceIndex(0) --- >>> }()); 1 >^^^^^^^^^^^^ @@ -65,10 +64,10 @@ sourceFile:tests/cases/compiler/ref/a.ts 2 > } 3 > 4 > export class A { } -1 >Emitted(22, 13) Source(2, 18) + SourceIndex(0) -2 >Emitted(22, 14) Source(2, 19) + SourceIndex(0) -3 >Emitted(22, 14) Source(2, 1) + SourceIndex(0) -4 >Emitted(22, 18) Source(2, 19) + SourceIndex(0) +1 >Emitted(22, 13) Source(1, 18) + SourceIndex(0) +2 >Emitted(22, 14) Source(1, 19) + SourceIndex(0) +3 >Emitted(22, 14) Source(1, 1) + SourceIndex(0) +4 >Emitted(22, 18) Source(1, 19) + SourceIndex(0) --- >>> exports_1("A", A); >>> } @@ -77,8 +76,8 @@ sourceFile:tests/cases/compiler/ref/a.ts 1-> > 2 > -1->Emitted(24, 9) Source(3, 1) + SourceIndex(0) -2 >Emitted(24, 10) Source(3, 2) + SourceIndex(0) +1->Emitted(24, 9) Source(2, 1) + SourceIndex(0) +2 >Emitted(24, 10) Source(2, 2) + SourceIndex(0) --- ------------------------------------------------------------------- emittedFile:all.js diff --git a/tests/baselines/reference/outModuleConcatSystem.symbols b/tests/baselines/reference/outModuleConcatSystem.symbols index 349de40815a17..8f2ac39afbead 100644 --- a/tests/baselines/reference/outModuleConcatSystem.symbols +++ b/tests/baselines/reference/outModuleConcatSystem.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - export class A { } >A : Symbol(A, Decl(a.ts, 0, 0)) diff --git a/tests/baselines/reference/outModuleConcatSystem.types b/tests/baselines/reference/outModuleConcatSystem.types index 6e0d93988533a..f1f7a7f12f99c 100644 --- a/tests/baselines/reference/outModuleConcatSystem.types +++ b/tests/baselines/reference/outModuleConcatSystem.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - export class A { } >A : A diff --git a/tests/baselines/reference/outModuleConcatUmd.errors.txt b/tests/baselines/reference/outModuleConcatUmd.errors.txt index 8695199c7eb74..7332f41a4da74 100644 --- a/tests/baselines/reference/outModuleConcatUmd.errors.txt +++ b/tests/baselines/reference/outModuleConcatUmd.errors.txt @@ -3,7 +3,6 @@ error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. !!! error TS6082: Only 'amd' and 'system' modules are supported alongside --outFile. ==== tests/cases/compiler/ref/a.ts (0 errors) ==== - // This should error export class A { } diff --git a/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.errors.txt b/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.errors.txt index 07282cd135031..6dccd8c38b03d 100644 --- a/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.errors.txt +++ b/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.ts(2,14): error TS6131: Cannot compile modules using option 'outFile' unless the '--module' flag is 'amd' or 'system'. +tests/cases/compiler/a.ts(1,14): error TS6131: Cannot compile modules using option 'outFile' unless the '--module' flag is 'amd' or 'system'. ==== tests/cases/compiler/a.ts (1 errors) ==== - export class A { } // module ~ !!! error TS6131: Cannot compile modules using option 'outFile' unless the '--module' flag is 'amd' or 'system'. diff --git a/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.js b/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.js index 48548400f7f1b..a705539797a50 100644 --- a/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.js +++ b/tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/outModuleConcatUnspecifiedModuleKind.ts] //// //// [a.ts] - export class A { } // module //// [b.ts] diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.js b/tests/baselines/reference/outModuleTripleSlashRefs.js index c45414b5e6202..897b698e9e7f2 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.js +++ b/tests/baselines/reference/outModuleTripleSlashRefs.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/outModuleTripleSlashRefs.ts] //// //// [a.ts] - /// export class A { member: typeof GlobalFoo; diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.js.map b/tests/baselines/reference/outModuleTripleSlashRefs.js.map index 8b552ec3fb355..cfa37772090ed 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.js.map +++ b/tests/baselines/reference/outModuleTripleSlashRefs.js.map @@ -1,2 +1,2 @@ //// [all.js.map] -{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/b.ts","tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,iCAAiC;AACjC;IAAA;IAEA,CAAC;IAAD,UAAC;AAAD,CAAC,AAFD,IAEC;;;;ICFD,+BAA+B;IAC/B;QAAA;QAEA,CAAC;QAAD,QAAC;IAAD,CAAC,AAFD,IAEC;IAFY,cAAC;;;;;ICDd;QAAuB,qBAAC;QAAxB;;QAA2B,CAAC;QAAD,QAAC;IAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;IAAf,cAAC"} \ No newline at end of file +{"version":3,"file":"all.js","sourceRoot":"","sources":["tests/cases/compiler/ref/b.ts","tests/cases/compiler/ref/a.ts","tests/cases/compiler/b.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,iCAAiC;AACjC;IAAA;IAEA,CAAC;IAAD,UAAC;AAAD,CAAC,AAFD,IAEC;;;;ICHD,+BAA+B;IAC/B;QAAA;QAEA,CAAC;QAAD,QAAC;IAAD,CAAC,AAFD,IAEC;IAFY,cAAC;;;;;ICAd;QAAuB,qBAAC;QAAxB;;QAA2B,CAAC;QAAD,QAAC;IAAD,CAAC,AAA5B,CAAuB,KAAC,GAAI;IAAf,cAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.sourcemap.txt b/tests/baselines/reference/outModuleTripleSlashRefs.sourcemap.txt index 231da040f11f1..74c2a0cf79835 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.sourcemap.txt +++ b/tests/baselines/reference/outModuleTripleSlashRefs.sourcemap.txt @@ -85,24 +85,23 @@ sourceFile:tests/cases/compiler/ref/a.ts >>> /// 1->^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -1-> - > +1-> 2 > /// -1->Emitted(20, 5) Source(2, 1) + SourceIndex(1) -2 >Emitted(20, 36) Source(2, 32) + SourceIndex(1) +1->Emitted(20, 5) Source(1, 1) + SourceIndex(1) +2 >Emitted(20, 36) Source(1, 32) + SourceIndex(1) --- >>> var A = (function () { 1 >^^^^ 2 > ^^^^^^^^^^^^^^^^^^^-> 1 > > -1 >Emitted(21, 5) Source(3, 1) + SourceIndex(1) +1 >Emitted(21, 5) Source(2, 1) + SourceIndex(1) --- >>> function A() { 1->^^^^^^^^ 2 > ^^-> 1-> -1->Emitted(22, 9) Source(3, 1) + SourceIndex(1) +1->Emitted(22, 9) Source(2, 1) + SourceIndex(1) --- >>> } 1->^^^^^^^^ @@ -112,16 +111,16 @@ sourceFile:tests/cases/compiler/ref/a.ts > member: typeof GlobalFoo; > 2 > } -1->Emitted(23, 9) Source(5, 1) + SourceIndex(1) -2 >Emitted(23, 10) Source(5, 2) + SourceIndex(1) +1->Emitted(23, 9) Source(4, 1) + SourceIndex(1) +2 >Emitted(23, 10) Source(4, 2) + SourceIndex(1) --- >>> return A; 1->^^^^^^^^ 2 > ^^^^^^^^ 1-> 2 > } -1->Emitted(24, 9) Source(5, 1) + SourceIndex(1) -2 >Emitted(24, 17) Source(5, 2) + SourceIndex(1) +1->Emitted(24, 9) Source(4, 1) + SourceIndex(1) +2 >Emitted(24, 17) Source(4, 2) + SourceIndex(1) --- >>> }()); 1 >^^^^ @@ -135,18 +134,18 @@ sourceFile:tests/cases/compiler/ref/a.ts 4 > export class A { > member: typeof GlobalFoo; > } -1 >Emitted(25, 5) Source(5, 1) + SourceIndex(1) -2 >Emitted(25, 6) Source(5, 2) + SourceIndex(1) -3 >Emitted(25, 6) Source(3, 1) + SourceIndex(1) -4 >Emitted(25, 10) Source(5, 2) + SourceIndex(1) +1 >Emitted(25, 5) Source(4, 1) + SourceIndex(1) +2 >Emitted(25, 6) Source(4, 2) + SourceIndex(1) +3 >Emitted(25, 6) Source(2, 1) + SourceIndex(1) +4 >Emitted(25, 10) Source(4, 2) + SourceIndex(1) --- >>> exports.A = A; 1->^^^^ 2 > ^^^^^^^^^^^^^^ 1-> 2 > A -1->Emitted(26, 5) Source(3, 14) + SourceIndex(1) -2 >Emitted(26, 19) Source(3, 15) + SourceIndex(1) +1->Emitted(26, 5) Source(2, 14) + SourceIndex(1) +2 >Emitted(26, 19) Source(2, 15) + SourceIndex(1) --- ------------------------------------------------------------------- emittedFile:all.js diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.symbols b/tests/baselines/reference/outModuleTripleSlashRefs.symbols index 5f137a9536175..21d93914fb706 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.symbols +++ b/tests/baselines/reference/outModuleTripleSlashRefs.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/ref/a.ts === - /// export class A { >A : Symbol(A, Decl(a.ts, 0, 0)) member: typeof GlobalFoo; ->member : Symbol(A.member, Decl(a.ts, 2, 16)) +>member : Symbol(A.member, Decl(a.ts, 1, 16)) >GlobalFoo : Symbol(GlobalFoo, Decl(b.ts, 4, 11)) } diff --git a/tests/baselines/reference/outModuleTripleSlashRefs.types b/tests/baselines/reference/outModuleTripleSlashRefs.types index 917704cce5abc..452a7f0b11acf 100644 --- a/tests/baselines/reference/outModuleTripleSlashRefs.types +++ b/tests/baselines/reference/outModuleTripleSlashRefs.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ref/a.ts === - /// export class A { >A : A diff --git a/tests/baselines/reference/overloadAssignmentCompat.errors.txt b/tests/baselines/reference/overloadAssignmentCompat.errors.txt index 446f9ce614f0a..35906ee92c9aa 100644 --- a/tests/baselines/reference/overloadAssignmentCompat.errors.txt +++ b/tests/baselines/reference/overloadAssignmentCompat.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/overloadAssignmentCompat.ts(35,10): error TS2394: Overload signature is not compatible with function implementation. +tests/cases/compiler/overloadAssignmentCompat.ts(34,10): error TS2394: Overload signature is not compatible with function implementation. ==== tests/cases/compiler/overloadAssignmentCompat.ts (1 errors) ==== - // ok - overload signatures are assignment compatible with their implementation class Accessor {} diff --git a/tests/baselines/reference/overloadAssignmentCompat.js b/tests/baselines/reference/overloadAssignmentCompat.js index 7915edd544602..bee754df3476a 100644 --- a/tests/baselines/reference/overloadAssignmentCompat.js +++ b/tests/baselines/reference/overloadAssignmentCompat.js @@ -1,5 +1,4 @@ //// [overloadAssignmentCompat.ts] - // ok - overload signatures are assignment compatible with their implementation class Accessor {} diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js index 94250b48cbc8c..92359d92ea82b 100644 --- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js +++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js @@ -1,5 +1,4 @@ //// [overloadOnConstAsTypeAnnotation.ts] - var f: (x: 'hi') => number = (x: 'hi') => { return 1; }; //// [overloadOnConstAsTypeAnnotation.js] diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.symbols b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.symbols index c420e50cda247..a6d24fe951160 100644 --- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.symbols +++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.symbols @@ -1,7 +1,6 @@ === tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts === - var f: (x: 'hi') => number = (x: 'hi') => { return 1; }; ->f : Symbol(f, Decl(overloadOnConstAsTypeAnnotation.ts, 1, 3)) ->x : Symbol(x, Decl(overloadOnConstAsTypeAnnotation.ts, 1, 8)) ->x : Symbol(x, Decl(overloadOnConstAsTypeAnnotation.ts, 1, 30)) +>f : Symbol(f, Decl(overloadOnConstAsTypeAnnotation.ts, 0, 3)) +>x : Symbol(x, Decl(overloadOnConstAsTypeAnnotation.ts, 0, 8)) +>x : Symbol(x, Decl(overloadOnConstAsTypeAnnotation.ts, 0, 30)) diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.types b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.types index 382fddfb78abf..5afe742dc680c 100644 --- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.types +++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.types @@ -1,5 +1,4 @@ === tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts === - var f: (x: 'hi') => number = (x: 'hi') => { return 1; }; >f : (x: "hi") => number >x : "hi" diff --git a/tests/baselines/reference/overloadResolutionTest1.errors.txt b/tests/baselines/reference/overloadResolutionTest1.errors.txt index 1bb1fb2041a80..8852f8638650a 100644 --- a/tests/baselines/reference/overloadResolutionTest1.errors.txt +++ b/tests/baselines/reference/overloadResolutionTest1.errors.txt @@ -1,17 +1,16 @@ -tests/cases/compiler/overloadResolutionTest1.ts(8,16): error TS2345: Argument of type '{ a: "s"; }[]' is not assignable to parameter of type '{ a: boolean; }[]'. +tests/cases/compiler/overloadResolutionTest1.ts(7,16): error TS2345: Argument of type '{ a: "s"; }[]' is not assignable to parameter of type '{ a: boolean; }[]'. Type '{ a: "s"; }' is not assignable to type '{ a: boolean; }'. Types of property 'a' are incompatible. Type '"s"' is not assignable to type 'boolean'. -tests/cases/compiler/overloadResolutionTest1.ts(19,15): error TS2345: Argument of type '{ a: "s"; }' is not assignable to parameter of type '{ a: boolean; }'. +tests/cases/compiler/overloadResolutionTest1.ts(18,15): error TS2345: Argument of type '{ a: "s"; }' is not assignable to parameter of type '{ a: boolean; }'. Types of property 'a' are incompatible. Type '"s"' is not assignable to type 'boolean'. -tests/cases/compiler/overloadResolutionTest1.ts(25,14): error TS2345: Argument of type '{ a: boolean; }' is not assignable to parameter of type '{ a: string; }'. +tests/cases/compiler/overloadResolutionTest1.ts(24,14): error TS2345: Argument of type '{ a: boolean; }' is not assignable to parameter of type '{ a: string; }'. Types of property 'a' are incompatible. Type 'boolean' is not assignable to type 'string'. ==== tests/cases/compiler/overloadResolutionTest1.ts (3 errors) ==== - function foo(bar:{a:number;}[]):string; function foo(bar:{a:boolean;}[]):number; function foo(bar:{a:any;}[]):any{ return bar }; diff --git a/tests/baselines/reference/overloadResolutionTest1.js b/tests/baselines/reference/overloadResolutionTest1.js index 60b99ebf7b91a..228d49ec020e6 100644 --- a/tests/baselines/reference/overloadResolutionTest1.js +++ b/tests/baselines/reference/overloadResolutionTest1.js @@ -1,5 +1,4 @@ //// [overloadResolutionTest1.ts] - function foo(bar:{a:number;}[]):string; function foo(bar:{a:boolean;}[]):number; function foo(bar:{a:any;}[]):any{ return bar }; diff --git a/tests/baselines/reference/overrideBaseIntersectionMethod.js b/tests/baselines/reference/overrideBaseIntersectionMethod.js index 26613f07469ab..ed17ef4e18948 100644 --- a/tests/baselines/reference/overrideBaseIntersectionMethod.js +++ b/tests/baselines/reference/overrideBaseIntersectionMethod.js @@ -1,5 +1,4 @@ //// [overrideBaseIntersectionMethod.ts] - // Repro from #14615 type Constructor = new (...args: any[]) => T; @@ -32,8 +31,8 @@ class Foo extends WithLocation(Point) { //// [overrideBaseIntersectionMethod.js] -// Repro from #14615 "use strict"; +// Repro from #14615 var __extends = (this && this.__extends) || (function () { var extendStatics = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || diff --git a/tests/baselines/reference/overrideBaseIntersectionMethod.symbols b/tests/baselines/reference/overrideBaseIntersectionMethod.symbols index 45a8454340821..368c9f50f523b 100644 --- a/tests/baselines/reference/overrideBaseIntersectionMethod.symbols +++ b/tests/baselines/reference/overrideBaseIntersectionMethod.symbols @@ -1,88 +1,87 @@ === tests/cases/compiler/overrideBaseIntersectionMethod.ts === - // Repro from #14615 type Constructor = new (...args: any[]) => T; >Constructor : Symbol(Constructor, Decl(overrideBaseIntersectionMethod.ts, 0, 0)) ->T : Symbol(T, Decl(overrideBaseIntersectionMethod.ts, 3, 17)) ->args : Symbol(args, Decl(overrideBaseIntersectionMethod.ts, 3, 27)) ->T : Symbol(T, Decl(overrideBaseIntersectionMethod.ts, 3, 17)) +>T : Symbol(T, Decl(overrideBaseIntersectionMethod.ts, 2, 17)) +>args : Symbol(args, Decl(overrideBaseIntersectionMethod.ts, 2, 27)) +>T : Symbol(T, Decl(overrideBaseIntersectionMethod.ts, 2, 17)) const WithLocation = >(Base: T) => class extends Base { ->WithLocation : Symbol(WithLocation, Decl(overrideBaseIntersectionMethod.ts, 5, 5)) ->T : Symbol(T, Decl(overrideBaseIntersectionMethod.ts, 5, 22)) +>WithLocation : Symbol(WithLocation, Decl(overrideBaseIntersectionMethod.ts, 4, 5)) +>T : Symbol(T, Decl(overrideBaseIntersectionMethod.ts, 4, 22)) >Constructor : Symbol(Constructor, Decl(overrideBaseIntersectionMethod.ts, 0, 0)) ->Point : Symbol(Point, Decl(overrideBaseIntersectionMethod.ts, 10, 1)) ->Base : Symbol(Base, Decl(overrideBaseIntersectionMethod.ts, 5, 52)) ->T : Symbol(T, Decl(overrideBaseIntersectionMethod.ts, 5, 22)) ->Base : Symbol(Base, Decl(overrideBaseIntersectionMethod.ts, 5, 52)) +>Point : Symbol(Point, Decl(overrideBaseIntersectionMethod.ts, 9, 1)) +>Base : Symbol(Base, Decl(overrideBaseIntersectionMethod.ts, 4, 52)) +>T : Symbol(T, Decl(overrideBaseIntersectionMethod.ts, 4, 22)) +>Base : Symbol(Base, Decl(overrideBaseIntersectionMethod.ts, 4, 52)) getLocation(): [number, number] { ->getLocation : Symbol((Anonymous class).getLocation, Decl(overrideBaseIntersectionMethod.ts, 5, 84)) +>getLocation : Symbol((Anonymous class).getLocation, Decl(overrideBaseIntersectionMethod.ts, 4, 84)) const [x,y] = super.getLocation(); ->x : Symbol(x, Decl(overrideBaseIntersectionMethod.ts, 7, 11)) ->y : Symbol(y, Decl(overrideBaseIntersectionMethod.ts, 7, 13)) ->super.getLocation : Symbol(Point.getLocation, Decl(overrideBaseIntersectionMethod.ts, 13, 53)) ->super : Symbol(Point, Decl(overrideBaseIntersectionMethod.ts, 10, 1)) ->getLocation : Symbol(Point.getLocation, Decl(overrideBaseIntersectionMethod.ts, 13, 53)) +>x : Symbol(x, Decl(overrideBaseIntersectionMethod.ts, 6, 11)) +>y : Symbol(y, Decl(overrideBaseIntersectionMethod.ts, 6, 13)) +>super.getLocation : Symbol(Point.getLocation, Decl(overrideBaseIntersectionMethod.ts, 12, 53)) +>super : Symbol(Point, Decl(overrideBaseIntersectionMethod.ts, 9, 1)) +>getLocation : Symbol(Point.getLocation, Decl(overrideBaseIntersectionMethod.ts, 12, 53)) return [this.x | x, this.y | y]; ->this.x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 13, 14)) ->this : Symbol((Anonymous class), Decl(overrideBaseIntersectionMethod.ts, 5, 63)) ->x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 13, 14)) ->x : Symbol(x, Decl(overrideBaseIntersectionMethod.ts, 7, 11)) ->this.y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 13, 31)) ->this : Symbol((Anonymous class), Decl(overrideBaseIntersectionMethod.ts, 5, 63)) ->y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 13, 31)) ->y : Symbol(y, Decl(overrideBaseIntersectionMethod.ts, 7, 13)) +>this.x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 12, 14)) +>this : Symbol((Anonymous class), Decl(overrideBaseIntersectionMethod.ts, 4, 63)) +>x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 12, 14)) +>x : Symbol(x, Decl(overrideBaseIntersectionMethod.ts, 6, 11)) +>this.y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 12, 31)) +>this : Symbol((Anonymous class), Decl(overrideBaseIntersectionMethod.ts, 4, 63)) +>y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 12, 31)) +>y : Symbol(y, Decl(overrideBaseIntersectionMethod.ts, 6, 13)) } } class Point { ->Point : Symbol(Point, Decl(overrideBaseIntersectionMethod.ts, 10, 1)) +>Point : Symbol(Point, Decl(overrideBaseIntersectionMethod.ts, 9, 1)) constructor(public x: number, public y: number) { } ->x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 13, 14)) ->y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 13, 31)) +>x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 12, 14)) +>y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 12, 31)) getLocation(): [number, number] { ->getLocation : Symbol(Point.getLocation, Decl(overrideBaseIntersectionMethod.ts, 13, 53)) +>getLocation : Symbol(Point.getLocation, Decl(overrideBaseIntersectionMethod.ts, 12, 53)) return [0,0]; } } class Foo extends WithLocation(Point) { ->Foo : Symbol(Foo, Decl(overrideBaseIntersectionMethod.ts, 17, 1)) ->WithLocation : Symbol(WithLocation, Decl(overrideBaseIntersectionMethod.ts, 5, 5)) ->Point : Symbol(Point, Decl(overrideBaseIntersectionMethod.ts, 10, 1)) +>Foo : Symbol(Foo, Decl(overrideBaseIntersectionMethod.ts, 16, 1)) +>WithLocation : Symbol(WithLocation, Decl(overrideBaseIntersectionMethod.ts, 4, 5)) +>Point : Symbol(Point, Decl(overrideBaseIntersectionMethod.ts, 9, 1)) calculate() { ->calculate : Symbol(Foo.calculate, Decl(overrideBaseIntersectionMethod.ts, 19, 39)) +>calculate : Symbol(Foo.calculate, Decl(overrideBaseIntersectionMethod.ts, 18, 39)) return this.x + this.y; ->this.x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 13, 14)) ->this : Symbol(Foo, Decl(overrideBaseIntersectionMethod.ts, 17, 1)) ->x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 13, 14)) ->this.y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 13, 31)) ->this : Symbol(Foo, Decl(overrideBaseIntersectionMethod.ts, 17, 1)) ->y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 13, 31)) +>this.x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 12, 14)) +>this : Symbol(Foo, Decl(overrideBaseIntersectionMethod.ts, 16, 1)) +>x : Symbol(Point.x, Decl(overrideBaseIntersectionMethod.ts, 12, 14)) +>this.y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 12, 31)) +>this : Symbol(Foo, Decl(overrideBaseIntersectionMethod.ts, 16, 1)) +>y : Symbol(Point.y, Decl(overrideBaseIntersectionMethod.ts, 12, 31)) } getLocation() { ->getLocation : Symbol(Foo.getLocation, Decl(overrideBaseIntersectionMethod.ts, 22, 3)) +>getLocation : Symbol(Foo.getLocation, Decl(overrideBaseIntersectionMethod.ts, 21, 3)) return super.getLocation() ->super.getLocation : Symbol(getLocation, Decl(overrideBaseIntersectionMethod.ts, 5, 84), Decl(overrideBaseIntersectionMethod.ts, 13, 53)) ->getLocation : Symbol(getLocation, Decl(overrideBaseIntersectionMethod.ts, 5, 84), Decl(overrideBaseIntersectionMethod.ts, 13, 53)) +>super.getLocation : Symbol(getLocation, Decl(overrideBaseIntersectionMethod.ts, 4, 84), Decl(overrideBaseIntersectionMethod.ts, 12, 53)) +>getLocation : Symbol(getLocation, Decl(overrideBaseIntersectionMethod.ts, 4, 84), Decl(overrideBaseIntersectionMethod.ts, 12, 53)) } whereAmI() { ->whereAmI : Symbol(Foo.whereAmI, Decl(overrideBaseIntersectionMethod.ts, 25, 3)) +>whereAmI : Symbol(Foo.whereAmI, Decl(overrideBaseIntersectionMethod.ts, 24, 3)) return this.getLocation(); ->this.getLocation : Symbol(Foo.getLocation, Decl(overrideBaseIntersectionMethod.ts, 22, 3)) ->this : Symbol(Foo, Decl(overrideBaseIntersectionMethod.ts, 17, 1)) ->getLocation : Symbol(Foo.getLocation, Decl(overrideBaseIntersectionMethod.ts, 22, 3)) +>this.getLocation : Symbol(Foo.getLocation, Decl(overrideBaseIntersectionMethod.ts, 21, 3)) +>this : Symbol(Foo, Decl(overrideBaseIntersectionMethod.ts, 16, 1)) +>getLocation : Symbol(Foo.getLocation, Decl(overrideBaseIntersectionMethod.ts, 21, 3)) } } diff --git a/tests/baselines/reference/overrideBaseIntersectionMethod.types b/tests/baselines/reference/overrideBaseIntersectionMethod.types index 3e31211bdbf21..b5412b18c0707 100644 --- a/tests/baselines/reference/overrideBaseIntersectionMethod.types +++ b/tests/baselines/reference/overrideBaseIntersectionMethod.types @@ -1,5 +1,4 @@ === tests/cases/compiler/overrideBaseIntersectionMethod.ts === - // Repro from #14615 type Constructor = new (...args: any[]) => T; diff --git a/tests/baselines/reference/packageJsonMain.js b/tests/baselines/reference/packageJsonMain.js index 96509ab639ee5..8a545c490163a 100644 --- a/tests/baselines/reference/packageJsonMain.js +++ b/tests/baselines/reference/packageJsonMain.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/moduleResolution/packageJsonMain.ts] //// //// [package.json] - { "main": "oof" } //// [oof.js] diff --git a/tests/baselines/reference/packageJsonMain_isNonRecursive.errors.txt b/tests/baselines/reference/packageJsonMain_isNonRecursive.errors.txt index a886fe3dca51f..d7e80990bc16d 100644 --- a/tests/baselines/reference/packageJsonMain_isNonRecursive.errors.txt +++ b/tests/baselines/reference/packageJsonMain_isNonRecursive.errors.txt @@ -7,7 +7,6 @@ !!! error TS2307: Cannot find module 'foo'. ==== /node_modules/foo/package.json (0 errors) ==== - { "main": "oof" } ==== /node_modules/foo/oof/package.json (0 errors) ==== diff --git a/tests/baselines/reference/packageJsonMain_isNonRecursive.js b/tests/baselines/reference/packageJsonMain_isNonRecursive.js index 97d7bbdf05b9b..61d98c81f112e 100644 --- a/tests/baselines/reference/packageJsonMain_isNonRecursive.js +++ b/tests/baselines/reference/packageJsonMain_isNonRecursive.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/moduleResolution/packageJsonMain_isNonRecursive.ts] //// //// [package.json] - { "main": "oof" } //// [package.json] diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.js b/tests/baselines/reference/paramterDestrcuturingDeclaration.js index 6920f22b0d404..a969939fdc2ca 100644 --- a/tests/baselines/reference/paramterDestrcuturingDeclaration.js +++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.js @@ -1,5 +1,4 @@ //// [paramterDestrcuturingDeclaration.ts] - interface C { ({p: name}): any; new ({p: boolean}): any; diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols b/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols index dd11b302eea31..c3ff6046bbf03 100644 --- a/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols +++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/paramterDestrcuturingDeclaration.ts === - interface C { >C : Symbol(C, Decl(paramterDestrcuturingDeclaration.ts, 0, 0)) ({p: name}): any; >p : Symbol(p) ->name : Symbol(name, Decl(paramterDestrcuturingDeclaration.ts, 2, 6)) +>name : Symbol(name, Decl(paramterDestrcuturingDeclaration.ts, 1, 6)) new ({p: boolean}): any; >p : Symbol(p) ->boolean : Symbol(boolean, Decl(paramterDestrcuturingDeclaration.ts, 3, 10)) +>boolean : Symbol(boolean, Decl(paramterDestrcuturingDeclaration.ts, 2, 10)) } diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.types b/tests/baselines/reference/paramterDestrcuturingDeclaration.types index 4b49ce22035c7..e71a274a6d28a 100644 --- a/tests/baselines/reference/paramterDestrcuturingDeclaration.types +++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.types @@ -1,5 +1,4 @@ === tests/cases/compiler/paramterDestrcuturingDeclaration.ts === - interface C { >C : C diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.errors.txt b/tests/baselines/reference/parenthesizedContexualTyping1.errors.txt index c77d571f270fc..3ee2e2cfde414 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping1.errors.txt +++ b/tests/baselines/reference/parenthesizedContexualTyping1.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(28,32): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(28,56): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(29,33): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(29,57): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(27,32): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(27,56): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(28,33): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts(28,57): error TS2695: Left side of comma operator is unused and has no side effects. ==== tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts (4 errors) ==== - function fun(g: (x: T) => T, x: T): T; function fun(g: (x: T) => T, h: (y: T) => T, x: T): T; function fun(g: (x: T) => T, x: T): T { diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.js b/tests/baselines/reference/parenthesizedContexualTyping1.js index 2f1e9ff62fc18..9d6bd43889f76 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping1.js +++ b/tests/baselines/reference/parenthesizedContexualTyping1.js @@ -1,5 +1,4 @@ //// [parenthesizedContexualTyping1.ts] - function fun(g: (x: T) => T, x: T): T; function fun(g: (x: T) => T, h: (y: T) => T, x: T): T; function fun(g: (x: T) => T, x: T): T { diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.js b/tests/baselines/reference/parenthesizedContexualTyping3.js index 6cc162a44d178..528e773e9ddaa 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping3.js +++ b/tests/baselines/reference/parenthesizedContexualTyping3.js @@ -1,5 +1,4 @@ //// [parenthesizedContexualTyping3.ts] - // Contextual typing for parenthesized substitution expressions in tagged templates. /** diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.symbols b/tests/baselines/reference/parenthesizedContexualTyping3.symbols index 1d4bce3f23047..25ef572e230e5 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping3.symbols +++ b/tests/baselines/reference/parenthesizedContexualTyping3.symbols @@ -1,12 +1,24 @@ === tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts === - // Contextual typing for parenthesized substitution expressions in tagged templates. /** * tempFun - Can't have fun for too long. */ function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) +>tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 5, 20)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 5, 51)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 5, 56)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 5, 67)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17)) + +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 6, 20)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) @@ -14,12 +26,16 @@ function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 6, 56)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 6, 67)) +>h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 6, 67)) +>y : Symbol(y, Decl(parenthesizedContexualTyping3.ts, 6, 72)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) +>T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 6, 83)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) -function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T { +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 7, 20)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) @@ -27,88 +43,71 @@ function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 56)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) ->h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 7, 67)) ->y : Symbol(y, Decl(parenthesizedContexualTyping3.ts, 7, 72)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 67)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 83)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) - -function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T { ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) ->tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 8, 20)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) ->g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 8, 51)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 8, 56)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 8, 67)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) ->T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17)) return g(x); ->g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 8, 51)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 8, 67)) +>g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 7, 51)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 67)) } var a = tempFun `${ x => x } ${ 10 }` ->a : Symbol(a, Decl(parenthesizedContexualTyping3.ts, 12, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 19)) +>a : Symbol(a, Decl(parenthesizedContexualTyping3.ts, 11, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 11, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 11, 19)) var b = tempFun `${ (x => x) } ${ 10 }` ->b : Symbol(b, Decl(parenthesizedContexualTyping3.ts, 13, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 21)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 21)) +>b : Symbol(b, Decl(parenthesizedContexualTyping3.ts, 12, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 21)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 21)) var c = tempFun `${ ((x => x)) } ${ 10 }` ->c : Symbol(c, Decl(parenthesizedContexualTyping3.ts, 14, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 22)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 22)) +>c : Symbol(c, Decl(parenthesizedContexualTyping3.ts, 13, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 22)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 22)) var d = tempFun `${ x => x } ${ x => x } ${ 10 }` ->d : Symbol(d, Decl(parenthesizedContexualTyping3.ts, 15, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) +>d : Symbol(d, Decl(parenthesizedContexualTyping3.ts, 14, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 19)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 31)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 31)) + +var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }` +>e : Symbol(e, Decl(parenthesizedContexualTyping3.ts, 15, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 31)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 31)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 33)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 33)) -var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }` ->e : Symbol(e, Decl(parenthesizedContexualTyping3.ts, 16, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) +var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }` +>f : Symbol(f, Decl(parenthesizedContexualTyping3.ts, 16, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 33)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 33)) - -var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }` ->f : Symbol(f, Decl(parenthesizedContexualTyping3.ts, 17, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 19)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 34)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 34)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 34)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 34)) var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }` ->g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 18, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) +>g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 17, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 21)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 21)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 37)) +>x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 37)) + +var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }` +>h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 18, 3)) +>tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37)) - -var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }` ->h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 19, 3)) ->tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 21)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 21)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 37)) ->x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 37)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.types b/tests/baselines/reference/parenthesizedContexualTyping3.types index 522228b260d89..a7d927537e253 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping3.types +++ b/tests/baselines/reference/parenthesizedContexualTyping3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts === - // Contextual typing for parenthesized substitution expressions in tagged templates. /** diff --git a/tests/baselines/reference/parseTypes.errors.txt b/tests/baselines/reference/parseTypes.errors.txt index 184137fe22032..aca1ddff31355 100644 --- a/tests/baselines/reference/parseTypes.errors.txt +++ b/tests/baselines/reference/parseTypes.errors.txt @@ -1,13 +1,12 @@ +tests/cases/compiler/parseTypes.ts(8,1): error TS2322: Type '(s: string) => void' is not assignable to type '() => number'. tests/cases/compiler/parseTypes.ts(9,1): error TS2322: Type '(s: string) => void' is not assignable to type '() => number'. -tests/cases/compiler/parseTypes.ts(10,1): error TS2322: Type '(s: string) => void' is not assignable to type '() => number'. -tests/cases/compiler/parseTypes.ts(11,1): error TS2322: Type '(s: string) => void' is not assignable to type '{ [x: number]: number; }'. +tests/cases/compiler/parseTypes.ts(10,1): error TS2322: Type '(s: string) => void' is not assignable to type '{ [x: number]: number; }'. Index signature is missing in type '(s: string) => void'. -tests/cases/compiler/parseTypes.ts(12,1): error TS2322: Type '(s: string) => void' is not assignable to type 'new () => number'. +tests/cases/compiler/parseTypes.ts(11,1): error TS2322: Type '(s: string) => void' is not assignable to type 'new () => number'. Type '(s: string) => void' provides no match for the signature 'new (): number'. ==== tests/cases/compiler/parseTypes.ts (4 errors) ==== - var x = <() => number>null; var y = <{(): number; }>null; var z = <{new(): number; }>null diff --git a/tests/baselines/reference/parseTypes.js b/tests/baselines/reference/parseTypes.js index 08cc9f2a6bd0a..8d6c0c943bce0 100644 --- a/tests/baselines/reference/parseTypes.js +++ b/tests/baselines/reference/parseTypes.js @@ -1,5 +1,4 @@ //// [parseTypes.ts] - var x = <() => number>null; var y = <{(): number; }>null; var z = <{new(): number; }>null diff --git a/tests/baselines/reference/parser10.1.1-8gs.errors.txt b/tests/baselines/reference/parser10.1.1-8gs.errors.txt index 75ab54029a63b..84e45644e9409 100644 --- a/tests/baselines/reference/parser10.1.1-8gs.errors.txt +++ b/tests/baselines/reference/parser10.1.1-8gs.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,7): error TS2304: Cannot find name 'NotEarlyError'. -tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(18,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode. +tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(16,7): error TS2304: Cannot find name 'NotEarlyError'. +tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode. ==== tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts (2 errors) ==== - /// Copyright (c) 2012 Ecma International. All rights reserved. /// Ecma International makes this code available under the terms and conditions set /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the diff --git a/tests/baselines/reference/parser10.1.1-8gs.js b/tests/baselines/reference/parser10.1.1-8gs.js index fb3b96f6baffb..e7d342cf1f105 100644 --- a/tests/baselines/reference/parser10.1.1-8gs.js +++ b/tests/baselines/reference/parser10.1.1-8gs.js @@ -1,5 +1,4 @@ //// [parser10.1.1-8gs.ts] - /// Copyright (c) 2012 Ecma International. All rights reserved. /// Ecma International makes this code available under the terms and conditions set /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the diff --git a/tests/baselines/reference/parser768531.js b/tests/baselines/reference/parser768531.js index 462db3742b30a..26e22117717b1 100644 --- a/tests/baselines/reference/parser768531.js +++ b/tests/baselines/reference/parser768531.js @@ -1,5 +1,4 @@ //// [parser768531.ts] - {a: 3} /x/ diff --git a/tests/baselines/reference/parser768531.symbols b/tests/baselines/reference/parser768531.symbols index f180922c7e081..2da2298c8e207 100644 --- a/tests/baselines/reference/parser768531.symbols +++ b/tests/baselines/reference/parser768531.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts === - -No type information for this code.{a: 3} +{a: 3} No type information for this code./x/ No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/parser768531.types b/tests/baselines/reference/parser768531.types index 17bae7161fa1c..e4b8e1eb70daa 100644 --- a/tests/baselines/reference/parser768531.types +++ b/tests/baselines/reference/parser768531.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts === - {a: 3} >a : any >3 : 3 diff --git a/tests/baselines/reference/parserClass2.errors.txt b/tests/baselines/reference/parserClass2.errors.txt index 6bd60fc84d7f7..938cba9aa6a1d 100644 --- a/tests/baselines/reference/parserClass2.errors.txt +++ b/tests/baselines/reference/parserClass2.errors.txt @@ -1,11 +1,9 @@ -tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(3,43): error TS2304: Cannot find name 'ILogger'. -tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(4,37): error TS2304: Cannot find name 'ILogger'. -tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(5,18): error TS2339: Property '_information' does not exist on type 'LoggerAdapter'. +tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(1,43): error TS2304: Cannot find name 'ILogger'. +tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(2,37): error TS2304: Cannot find name 'ILogger'. +tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts(3,18): error TS2339: Property '_information' does not exist on type 'LoggerAdapter'. ==== tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClass2.ts (3 errors) ==== - - export class LoggerAdapter implements ILogger { ~~~~~~~ !!! error TS2304: Cannot find name 'ILogger'. diff --git a/tests/baselines/reference/parserClass2.js b/tests/baselines/reference/parserClass2.js index 0d47a388accc3..80c1fd8ff6ae8 100644 --- a/tests/baselines/reference/parserClass2.js +++ b/tests/baselines/reference/parserClass2.js @@ -1,6 +1,4 @@ //// [parserClass2.ts] - - export class LoggerAdapter implements ILogger { constructor (public logger: ILogger) { this._information = this.logger.information(); diff --git a/tests/baselines/reference/parserEnum1.js b/tests/baselines/reference/parserEnum1.js index 43cdc626ab86a..10f24cc86017d 100644 --- a/tests/baselines/reference/parserEnum1.js +++ b/tests/baselines/reference/parserEnum1.js @@ -1,6 +1,4 @@ //// [parserEnum1.ts] - - export enum SignatureFlags { None = 0, IsIndexer = 1, diff --git a/tests/baselines/reference/parserEnum1.symbols b/tests/baselines/reference/parserEnum1.symbols index ec9a3d8aa2160..ef245464c6e15 100644 --- a/tests/baselines/reference/parserEnum1.symbols +++ b/tests/baselines/reference/parserEnum1.symbols @@ -1,18 +1,16 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum1.ts === - - export enum SignatureFlags { >SignatureFlags : Symbol(SignatureFlags, Decl(parserEnum1.ts, 0, 0)) None = 0, ->None : Symbol(SignatureFlags.None, Decl(parserEnum1.ts, 2, 32)) +>None : Symbol(SignatureFlags.None, Decl(parserEnum1.ts, 0, 32)) IsIndexer = 1, ->IsIndexer : Symbol(SignatureFlags.IsIndexer, Decl(parserEnum1.ts, 3, 17)) +>IsIndexer : Symbol(SignatureFlags.IsIndexer, Decl(parserEnum1.ts, 1, 17)) IsStringIndexer = 1 << 1, ->IsStringIndexer : Symbol(SignatureFlags.IsStringIndexer, Decl(parserEnum1.ts, 4, 22)) +>IsStringIndexer : Symbol(SignatureFlags.IsStringIndexer, Decl(parserEnum1.ts, 2, 22)) IsNumberIndexer = 1 << 2, ->IsNumberIndexer : Symbol(SignatureFlags.IsNumberIndexer, Decl(parserEnum1.ts, 5, 33)) +>IsNumberIndexer : Symbol(SignatureFlags.IsNumberIndexer, Decl(parserEnum1.ts, 3, 33)) } diff --git a/tests/baselines/reference/parserEnum1.types b/tests/baselines/reference/parserEnum1.types index 42161656a1e88..5543a336463f6 100644 --- a/tests/baselines/reference/parserEnum1.types +++ b/tests/baselines/reference/parserEnum1.types @@ -1,6 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum1.ts === - - export enum SignatureFlags { >SignatureFlags : SignatureFlags diff --git a/tests/baselines/reference/parserEnum2.js b/tests/baselines/reference/parserEnum2.js index 0fa0633d2801e..b1f28f6c5025a 100644 --- a/tests/baselines/reference/parserEnum2.js +++ b/tests/baselines/reference/parserEnum2.js @@ -1,6 +1,4 @@ //// [parserEnum2.ts] - - export enum SignatureFlags { None = 0, IsIndexer = 1, diff --git a/tests/baselines/reference/parserEnum2.symbols b/tests/baselines/reference/parserEnum2.symbols index dc745ca726ee8..85fff2cfdbcd7 100644 --- a/tests/baselines/reference/parserEnum2.symbols +++ b/tests/baselines/reference/parserEnum2.symbols @@ -1,18 +1,16 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum2.ts === - - export enum SignatureFlags { >SignatureFlags : Symbol(SignatureFlags, Decl(parserEnum2.ts, 0, 0)) None = 0, ->None : Symbol(SignatureFlags.None, Decl(parserEnum2.ts, 2, 32)) +>None : Symbol(SignatureFlags.None, Decl(parserEnum2.ts, 0, 32)) IsIndexer = 1, ->IsIndexer : Symbol(SignatureFlags.IsIndexer, Decl(parserEnum2.ts, 3, 17)) +>IsIndexer : Symbol(SignatureFlags.IsIndexer, Decl(parserEnum2.ts, 1, 17)) IsStringIndexer = 1 << 1, ->IsStringIndexer : Symbol(SignatureFlags.IsStringIndexer, Decl(parserEnum2.ts, 4, 22)) +>IsStringIndexer : Symbol(SignatureFlags.IsStringIndexer, Decl(parserEnum2.ts, 2, 22)) IsNumberIndexer = 1 << 2 ->IsNumberIndexer : Symbol(SignatureFlags.IsNumberIndexer, Decl(parserEnum2.ts, 5, 33)) +>IsNumberIndexer : Symbol(SignatureFlags.IsNumberIndexer, Decl(parserEnum2.ts, 3, 33)) } diff --git a/tests/baselines/reference/parserEnum2.types b/tests/baselines/reference/parserEnum2.types index 5c0a8fec2d400..d21420a032049 100644 --- a/tests/baselines/reference/parserEnum2.types +++ b/tests/baselines/reference/parserEnum2.types @@ -1,6 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum2.ts === - - export enum SignatureFlags { >SignatureFlags : SignatureFlags diff --git a/tests/baselines/reference/parserEnum3.js b/tests/baselines/reference/parserEnum3.js index b9b9e743e4bdc..3e5595911285a 100644 --- a/tests/baselines/reference/parserEnum3.js +++ b/tests/baselines/reference/parserEnum3.js @@ -1,6 +1,4 @@ //// [parserEnum3.ts] - - export enum SignatureFlags { } diff --git a/tests/baselines/reference/parserEnum3.symbols b/tests/baselines/reference/parserEnum3.symbols index 01e55693335db..6189bf17abf2a 100644 --- a/tests/baselines/reference/parserEnum3.symbols +++ b/tests/baselines/reference/parserEnum3.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum3.ts === - - export enum SignatureFlags { >SignatureFlags : Symbol(SignatureFlags, Decl(parserEnum3.ts, 0, 0)) } diff --git a/tests/baselines/reference/parserEnum3.types b/tests/baselines/reference/parserEnum3.types index 21527136b32e2..29cdea8ef6836 100644 --- a/tests/baselines/reference/parserEnum3.types +++ b/tests/baselines/reference/parserEnum3.types @@ -1,6 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum3.ts === - - export enum SignatureFlags { >SignatureFlags : SignatureFlags } diff --git a/tests/baselines/reference/parserEnum4.errors.txt b/tests/baselines/reference/parserEnum4.errors.txt index d9a57b21daae5..e919ff3678dcf 100644 --- a/tests/baselines/reference/parserEnum4.errors.txt +++ b/tests/baselines/reference/parserEnum4.errors.txt @@ -1,9 +1,7 @@ -tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum4.ts(4,9): error TS1132: Enum member expected. +tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum4.ts(2,9): error TS1132: Enum member expected. ==== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum4.ts (1 errors) ==== - - export enum SignatureFlags { , ~ diff --git a/tests/baselines/reference/parserEnum4.js b/tests/baselines/reference/parserEnum4.js index 96d3c8757eda0..90919ed8347ed 100644 --- a/tests/baselines/reference/parserEnum4.js +++ b/tests/baselines/reference/parserEnum4.js @@ -1,6 +1,4 @@ //// [parserEnum4.ts] - - export enum SignatureFlags { , } diff --git a/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.errors.txt b/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.errors.txt index e34e8b6072a63..eb32618af4bbf 100644 --- a/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.errors.txt +++ b/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(2,54): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(2,56): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(2,56): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(2,105): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(1,54): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(1,56): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(1,56): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts(1,105): error TS1005: ';' expected. ==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrayLiteralExpressions/parserErrorRecoveryArrayLiteralExpression3.ts (4 errors) ==== - var texCoords = [2, 2, 0.5000001192092895, 0.8749999 ; 403953552, 0.5000001192092895, 0.8749999403953552]; ~ !!! error TS1005: ',' expected. diff --git a/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.js b/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.js index c366c750cc734..ff590b1681c5a 100644 --- a/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.js +++ b/tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.js @@ -1,5 +1,4 @@ //// [parserErrorRecoveryArrayLiteralExpression3.ts] - var texCoords = [2, 2, 0.5000001192092895, 0.8749999 ; 403953552, 0.5000001192092895, 0.8749999403953552]; diff --git a/tests/baselines/reference/parserVariableDeclaration1.errors.txt b/tests/baselines/reference/parserVariableDeclaration1.errors.txt index 3011eb73123eb..e0617e2b159e5 100644 --- a/tests/baselines/reference/parserVariableDeclaration1.errors.txt +++ b/tests/baselines/reference/parserVariableDeclaration1.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(2,19): error TS2304: Cannot find name 'a'. -tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(3,15): error TS2304: Cannot find name 'b'. -tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(4,12): error TS2304: Cannot find name 'c'. -tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(5,14): error TS2304: Cannot find name 'd'. +tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(1,19): error TS2304: Cannot find name 'a'. +tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(2,15): error TS2304: Cannot find name 'b'. +tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(3,12): error TS2304: Cannot find name 'c'. +tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts(4,14): error TS2304: Cannot find name 'd'. ==== tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration1.ts (4 errors) ==== - var selection = a, ~ !!! error TS2304: Cannot find name 'a'. diff --git a/tests/baselines/reference/parserVariableDeclaration1.js b/tests/baselines/reference/parserVariableDeclaration1.js index 48bf07ebdb3c8..4ecddf8099aa4 100644 --- a/tests/baselines/reference/parserVariableDeclaration1.js +++ b/tests/baselines/reference/parserVariableDeclaration1.js @@ -1,5 +1,4 @@ //// [parserVariableDeclaration1.ts] - var selection = a, position = b, model = c, diff --git a/tests/baselines/reference/parser_breakTarget3.js b/tests/baselines/reference/parser_breakTarget3.js index 91ba9fb599369..0eceba87bf8d2 100644 --- a/tests/baselines/reference/parser_breakTarget3.js +++ b/tests/baselines/reference/parser_breakTarget3.js @@ -1,5 +1,4 @@ //// [parser_breakTarget3.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_breakTarget3.symbols b/tests/baselines/reference/parser_breakTarget3.symbols index 35184471d4d31..99ec413987af8 100644 --- a/tests/baselines/reference/parser_breakTarget3.symbols +++ b/tests/baselines/reference/parser_breakTarget3.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target1; diff --git a/tests/baselines/reference/parser_breakTarget3.types b/tests/baselines/reference/parser_breakTarget3.types index eb5c2cf68a5e9..997c7a52502c5 100644 --- a/tests/baselines/reference/parser_breakTarget3.types +++ b/tests/baselines/reference/parser_breakTarget3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/parser_breakTarget4.js b/tests/baselines/reference/parser_breakTarget4.js index 4516cf3e8f9b1..c6cadb5efa1af 100644 --- a/tests/baselines/reference/parser_breakTarget4.js +++ b/tests/baselines/reference/parser_breakTarget4.js @@ -1,5 +1,4 @@ //// [parser_breakTarget4.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_breakTarget4.symbols b/tests/baselines/reference/parser_breakTarget4.symbols index f4d4b2e4bffd1..042df67d9b282 100644 --- a/tests/baselines/reference/parser_breakTarget4.symbols +++ b/tests/baselines/reference/parser_breakTarget4.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target2; diff --git a/tests/baselines/reference/parser_breakTarget4.types b/tests/baselines/reference/parser_breakTarget4.types index 3a368eeb6c9c9..7aab34998ccc3 100644 --- a/tests/baselines/reference/parser_breakTarget4.types +++ b/tests/baselines/reference/parser_breakTarget4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/parser_continueTarget3.js b/tests/baselines/reference/parser_continueTarget3.js index ea1559346dee2..76a98a0e20428 100644 --- a/tests/baselines/reference/parser_continueTarget3.js +++ b/tests/baselines/reference/parser_continueTarget3.js @@ -1,5 +1,4 @@ //// [parser_continueTarget3.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_continueTarget3.symbols b/tests/baselines/reference/parser_continueTarget3.symbols index c522444ca1aef..2038671d215a6 100644 --- a/tests/baselines/reference/parser_continueTarget3.symbols +++ b/tests/baselines/reference/parser_continueTarget3.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target1; diff --git a/tests/baselines/reference/parser_continueTarget3.types b/tests/baselines/reference/parser_continueTarget3.types index 273c47f97cf0b..3367526020780 100644 --- a/tests/baselines/reference/parser_continueTarget3.types +++ b/tests/baselines/reference/parser_continueTarget3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/parser_continueTarget4.js b/tests/baselines/reference/parser_continueTarget4.js index 9ccaaac27e749..795cab2e2adaa 100644 --- a/tests/baselines/reference/parser_continueTarget4.js +++ b/tests/baselines/reference/parser_continueTarget4.js @@ -1,5 +1,4 @@ //// [parser_continueTarget4.ts] - target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_continueTarget4.symbols b/tests/baselines/reference/parser_continueTarget4.symbols index b7e770f9bf9c7..2b47099715ee1 100644 --- a/tests/baselines/reference/parser_continueTarget4.symbols +++ b/tests/baselines/reference/parser_continueTarget4.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts === - -No type information for this code.target1: +target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target2; diff --git a/tests/baselines/reference/parser_continueTarget4.types b/tests/baselines/reference/parser_continueTarget4.types index 21381823e7ca2..3f67b31f715a4 100644 --- a/tests/baselines/reference/parser_continueTarget4.types +++ b/tests/baselines/reference/parser_continueTarget4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts === - target1: >target1 : any diff --git a/tests/baselines/reference/parser_duplicateLabel3.js b/tests/baselines/reference/parser_duplicateLabel3.js index c2ea2769f18fc..9bd6c56356af9 100644 --- a/tests/baselines/reference/parser_duplicateLabel3.js +++ b/tests/baselines/reference/parser_duplicateLabel3.js @@ -1,5 +1,4 @@ //// [parser_duplicateLabel3.ts] - target: while (true) { function f() { diff --git a/tests/baselines/reference/parser_duplicateLabel3.symbols b/tests/baselines/reference/parser_duplicateLabel3.symbols index 7e238eb2916f9..20627a0e2b8f8 100644 --- a/tests/baselines/reference/parser_duplicateLabel3.symbols +++ b/tests/baselines/reference/parser_duplicateLabel3.symbols @@ -1,9 +1,8 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts === - target: while (true) { function f() { ->f : Symbol(f, Decl(parser_duplicateLabel3.ts, 2, 14)) +>f : Symbol(f, Decl(parser_duplicateLabel3.ts, 1, 14)) target: while (true) { diff --git a/tests/baselines/reference/parser_duplicateLabel3.types b/tests/baselines/reference/parser_duplicateLabel3.types index 8d62ee2a14d82..13e51b760d97f 100644 --- a/tests/baselines/reference/parser_duplicateLabel3.types +++ b/tests/baselines/reference/parser_duplicateLabel3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts === - target: >target : any diff --git a/tests/baselines/reference/parser_duplicateLabel4.js b/tests/baselines/reference/parser_duplicateLabel4.js index a949131442630..569a9bcd1023b 100644 --- a/tests/baselines/reference/parser_duplicateLabel4.js +++ b/tests/baselines/reference/parser_duplicateLabel4.js @@ -1,5 +1,4 @@ //// [parser_duplicateLabel4.ts] - target: while (true) { } diff --git a/tests/baselines/reference/parser_duplicateLabel4.symbols b/tests/baselines/reference/parser_duplicateLabel4.symbols index e7123de16008e..564531bf71bd8 100644 --- a/tests/baselines/reference/parser_duplicateLabel4.symbols +++ b/tests/baselines/reference/parser_duplicateLabel4.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts === - -No type information for this code.target: +target: No type information for this code.while (true) { No type information for this code.} No type information for this code. diff --git a/tests/baselines/reference/parser_duplicateLabel4.types b/tests/baselines/reference/parser_duplicateLabel4.types index 483cf8a005133..f14c79f431477 100644 --- a/tests/baselines/reference/parser_duplicateLabel4.types +++ b/tests/baselines/reference/parser_duplicateLabel4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts === - target: >target : any diff --git a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.js b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.js index 8b81ff506fe14..09951a1701055 100644 --- a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.js +++ b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.js @@ -1,5 +1,4 @@ //// [partiallyAnnotatedFunctionWitoutTypeParameter.ts] - // simple case declare function simple(f: (a: number, b: number) => void): {} diff --git a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.symbols b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.symbols index a7ed6b67d8317..aafbcb8271c69 100644 --- a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.symbols +++ b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/types/contextualTypes/partiallyAnnotatedFunction/partiallyAnnotatedFunctionWitoutTypeParameter.ts === - // simple case declare function simple(f: (a: number, b: number) => void): {} >simple : Symbol(simple, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 0, 0)) ->f : Symbol(f, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 2, 24)) ->a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 2, 28)) ->b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 2, 38)) +>f : Symbol(f, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 1, 24)) +>a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 1, 28)) +>b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 1, 38)) simple((a: number, b) => {}) >simple : Symbol(simple, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 0, 0)) ->a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 4, 8)) ->b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 4, 18)) +>a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 3, 8)) +>b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 3, 18)) simple((a, b: number) => {}) >simple : Symbol(simple, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 0, 0)) ->a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 5, 8)) ->b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 5, 10)) +>a : Symbol(a, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 4, 8)) +>b : Symbol(b, Decl(partiallyAnnotatedFunctionWitoutTypeParameter.ts, 4, 10)) diff --git a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.types b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.types index f07cd5a8928b8..1e37636ed9ed6 100644 --- a/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.types +++ b/tests/baselines/reference/partiallyAnnotatedFunctionWitoutTypeParameter.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/contextualTypes/partiallyAnnotatedFunction/partiallyAnnotatedFunctionWitoutTypeParameter.ts === - // simple case declare function simple(f: (a: number, b: number) => void): {} >simple : (f: (a: number, b: number) => void) => {} diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.js b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.js index 8809efa963a2a..16ef9260e8d12 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.js +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/pathMappingBasedModuleResolution3_classic.ts] //// //// [file1.ts] - // baseUrl set via command line import {x} from "folder2/file2" diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.symbols b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.symbols index 97ec40d4cb4d4..41e36accb1cdd 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.symbols +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.symbols @@ -1,18 +1,17 @@ === c:/root/folder1/file1.ts === - // baseUrl set via command line import {x} from "folder2/file2" ->x : Symbol(x, Decl(file1.ts, 3, 8)) +>x : Symbol(x, Decl(file1.ts, 2, 8)) declare function use(a: any): void; ->use : Symbol(use, Decl(file1.ts, 3, 31)) ->a : Symbol(a, Decl(file1.ts, 4, 21)) +>use : Symbol(use, Decl(file1.ts, 2, 31)) +>a : Symbol(a, Decl(file1.ts, 3, 21)) use(x.toExponential()); ->use : Symbol(use, Decl(file1.ts, 3, 31)) +>use : Symbol(use, Decl(file1.ts, 2, 31)) >x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(file1.ts, 3, 8)) +>x : Symbol(x, Decl(file1.ts, 2, 8)) >toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) === c:/root/folder2/file2.ts === diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.types b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.types index 17f9393226518..140a84768cf15 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.types +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_classic.types @@ -1,5 +1,4 @@ === c:/root/folder1/file1.ts === - // baseUrl set via command line import {x} from "folder2/file2" diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.js b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.js index cd0eb7d7794f3..969a98dc4cc21 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.js +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/pathMappingBasedModuleResolution3_node.ts] //// //// [file1.ts] - // baseUrl set via command line import {x} from "folder2/file2" @@ -30,8 +29,8 @@ var file3_1 = require("./file3"); // found with baseurl var file4_1 = require("file4"); // found with fallback exports.x = file3_1.x + file4_1.y; //// [file1.js] -// baseUrl set via command line "use strict"; +// baseUrl set via command line exports.__esModule = true; var file2_1 = require("folder2/file2"); use(file2_1.x.toExponential()); diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.symbols b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.symbols index 487dea2fb8983..de7155bef8507 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.symbols +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.symbols @@ -1,18 +1,17 @@ === c:/root/folder1/file1.ts === - // baseUrl set via command line import {x} from "folder2/file2" ->x : Symbol(x, Decl(file1.ts, 3, 8)) +>x : Symbol(x, Decl(file1.ts, 2, 8)) declare function use(a: any): void; ->use : Symbol(use, Decl(file1.ts, 3, 31)) ->a : Symbol(a, Decl(file1.ts, 4, 21)) +>use : Symbol(use, Decl(file1.ts, 2, 31)) +>a : Symbol(a, Decl(file1.ts, 3, 21)) use(x.toExponential()); ->use : Symbol(use, Decl(file1.ts, 3, 31)) +>use : Symbol(use, Decl(file1.ts, 2, 31)) >x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(file1.ts, 3, 8)) +>x : Symbol(x, Decl(file1.ts, 2, 8)) >toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) === c:/root/folder2/file2.ts === diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.types b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.types index 2c85b8ebcbd8e..ecfa2bea73644 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution3_node.types +++ b/tests/baselines/reference/pathMappingBasedModuleResolution3_node.types @@ -1,5 +1,4 @@ === c:/root/folder1/file1.ts === - // baseUrl set via command line import {x} from "folder2/file2" diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.js b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.js index a91cc9d8d5a47..3a31b8cd95020 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.js +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/pathMappingBasedModuleResolution_withExtension.ts] //// //// [foo.ts] - export function foo() {} //// [bar.js] diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.symbols b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.symbols index 717660067ecc0..355122b65e9d5 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.symbols +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.symbols @@ -6,7 +6,6 @@ import { bar } from "bar"; >bar : Symbol(bar, Decl(a.ts, 1, 8)) === /foo/foo.ts === - export function foo() {} >foo : Symbol(foo, Decl(foo.ts, 0, 0)) diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.types b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.types index 8d7c57b1d2701..a48c48acfc81b 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.types +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension.types @@ -6,7 +6,6 @@ import { bar } from "bar"; >bar : () => void === /foo/foo.ts === - export function foo() {} >foo : () => void diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.errors.txt b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.errors.txt index 7578f730c334c..4b038b99bcc59 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.errors.txt +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.errors.txt @@ -1,8 +1,7 @@ -/a.ts(2,21): error TS2307: Cannot find module 'foo'. +/a.ts(1,21): error TS2307: Cannot find module 'foo'. ==== /a.ts (1 errors) ==== - import { foo } from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.js b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.js index 4fded4a78ad15..e40fe32f46bfe 100644 --- a/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.js +++ b/tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.js @@ -1,5 +1,4 @@ //// [a.ts] - import { foo } from "foo"; diff --git a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.js b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.js index d51c2624b1cd6..79de4636f5294 100644 --- a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.js +++ b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.js @@ -1,5 +1,4 @@ //// [prefixUnaryOperatorsOnExportedVariables.ts] - export var x = false; export var y = 1; if (!x) { diff --git a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.symbols b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.symbols index c8293ef190289..4773921a3be81 100644 --- a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.symbols +++ b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.symbols @@ -1,42 +1,41 @@ === tests/cases/compiler/prefixUnaryOperatorsOnExportedVariables.ts === - export var x = false; ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) export var y = 1; ->y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 2, 10)) +>y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) if (!x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (+x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (-x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (~x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (void x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (typeof x) { ->x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) +>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 0, 10)) } if (++y) { ->y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 2, 10)) +>y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10)) } diff --git a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.types b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.types index 41df41af51bf8..42763ee46bdab 100644 --- a/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.types +++ b/tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.types @@ -1,5 +1,4 @@ === tests/cases/compiler/prefixUnaryOperatorsOnExportedVariables.ts === - export var x = false; >x : boolean >false : false diff --git a/tests/baselines/reference/printerApi/printsFileCorrectly.templateLiteral.js b/tests/baselines/reference/printerApi/printsFileCorrectly.templateLiteral.js new file mode 100644 index 0000000000000..fdfca9b218e81 --- /dev/null +++ b/tests/baselines/reference/printerApi/printsFileCorrectly.templateLiteral.js @@ -0,0 +1 @@ +let greeting = `Hi ${name}, how are you?`; diff --git a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt index debb5808493a7..67a62a2269c29 100644 --- a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt +++ b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt @@ -10,34 +10,33 @@ tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(411,20): error TS4039 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(414,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(420,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(422,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(9,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(15,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(21,16): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(27,9): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(117,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(121,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(161,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(164,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(167,16): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(170,9): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(176,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(178,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(211,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(217,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(223,20): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(229,13): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(319,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(323,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(363,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(366,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(369,20): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(372,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(378,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(8,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(14,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(20,16): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(26,9): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(116,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(120,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(160,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(163,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(166,16): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(169,9): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(175,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(177,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(210,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(216,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(222,20): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(228,13): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(318,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(322,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(362,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(365,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(368,20): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(371,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(377,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(379,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts (24 errors) ==== - class privateClass { } diff --git a/tests/baselines/reference/privacyAccessorDeclFile.js b/tests/baselines/reference/privacyAccessorDeclFile.js index 9d077d19e0697..9d92ba0d6846b 100644 --- a/tests/baselines/reference/privacyAccessorDeclFile.js +++ b/tests/baselines/reference/privacyAccessorDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyAccessorDeclFile.ts] //// //// [privacyAccessorDeclFile_externalModule.ts] - class privateClass { } diff --git a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt index b5d0ea8223ed4..6c1763f293ee0 100644 --- a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt +++ b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt @@ -110,7 +110,6 @@ tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(66,9): error } } ==== tests/cases/compiler/privacyCannotNameAccessorDeclFile_GlobalWidgets.ts (0 errors) ==== - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.js b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.js index d19869b0f0345..c2a781f9b6970 100644 --- a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.js +++ b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyCannotNameAccessorDeclFile.ts] //// //// [privacyCannotNameAccessorDeclFile_GlobalWidgets.ts] - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt index e76474d2d33df..f11937efb0c4f 100644 --- a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt +++ b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt @@ -85,8 +85,6 @@ tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(38,12): error var privateVarWithPrivateModulePropertyTypes= exporter.createExportedWidget2(); var privateVarWithPrivateModulePropertyTypes1 = exporter.createExportedWidget4(); ==== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts (0 errors) ==== - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.js b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.js index df24bf7025993..9da4e922f77bf 100644 --- a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.js +++ b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/privacyCannotNameVarTypeDeclFile.ts] //// //// [privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts] - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt index 95378c4c6949c..23559cd9a3c18 100644 --- a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt +++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt @@ -1,14 +1,13 @@ tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts(16,67): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(17,67): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(20,77): error TS2449: Class 'publicClassInPrivateModule' used before its declaration. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(22,69): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(22,83): error TS2449: Class 'publicClassInPrivateModule' used before its declaration. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(64,55): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClass' has or is using private name 'privateClass'. -tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(16,67): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(19,77): error TS2449: Class 'publicClassInPrivateModule' used before its declaration. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(21,69): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(21,83): error TS2449: Class 'publicClassInPrivateModule' used before its declaration. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(63,55): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClass' has or is using private name 'privateClass'. +tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(68,65): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts (6 errors) ==== - export module publicModule { export class publicClassInPublicModule { private f1() { diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js index 2803006c5b51e..857d52e99bf17 100644 --- a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js +++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyClassExtendsClauseDeclFile.ts] //// //// [privacyClassExtendsClauseDeclFile_externalModule.ts] - export module publicModule { export class publicClassInPublicModule { private f1() { diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt index 2681ee0e20e4f..586d4530c8e7e 100644 --- a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt +++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt @@ -1,13 +1,12 @@ tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts(14,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(15,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(20,79): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(23,78): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(63,65): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterface' has or is using private name 'privateInterface'. -tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,75): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(14,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(19,79): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(22,78): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(62,65): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterface' has or is using private name 'privateInterface'. +tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(67,75): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts (5 errors) ==== - export module publicModule { export interface publicInterfaceInPublicModule { } diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js index 3d78f2a804800..f4d48aae39d63 100644 --- a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js +++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyClassImplementsClauseDeclFile.ts] //// //// [privacyClassImplementsClauseDeclFile_externalModule.ts] - export module publicModule { export interface publicInterfaceInPublicModule { } diff --git a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt index 76fd8b4e80aec..432e209eaa840 100644 --- a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt +++ b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt @@ -177,8 +177,6 @@ tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts( function privateFunctionWithPrivateModuleParameterTypes1(param= exporter.createExportedWidget4()) { } ==== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts (0 errors) ==== - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.js b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.js index 00314bdceab46..6b0ea3cafd220 100644 --- a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.js +++ b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile.ts] //// //// [privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts] - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt index bc6229815f5a8..1a915d8b82cc4 100644 --- a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt +++ b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt @@ -148,8 +148,6 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error } ==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts (0 errors) ==== - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.js b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.js index 2124f8fbb24fa..61c7e0014db74 100644 --- a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.js +++ b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/privacyFunctionCannotNameReturnTypeDeclFile.ts] //// //// [privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts] - - declare module "GlobalWidgets" { export class Widget3 { name: string; diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt index 0e88e08e645ae..8367483ca979f 100644 --- a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt +++ b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt @@ -18,50 +18,49 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,71): err tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(266,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(268,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(9,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(10,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(11,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(33,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(37,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,54): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,83): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(84,63): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(93,78): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(99,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(100,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(101,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(104,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(106,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,67): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,109): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(111,70): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(113,85): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(141,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(142,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(143,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(165,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(169,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,58): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,87): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(216,67): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(225,82): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(231,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(232,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(233,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(236,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(238,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,71): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(243,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(8,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(9,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(10,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(32,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(36,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(40,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(40,54): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(40,83): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(83,63): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(92,78): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(98,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(99,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(100,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(103,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(105,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(107,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(107,67): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(107,109): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(110,70): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(112,85): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(140,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(141,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(142,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(164,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(168,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(172,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(172,58): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(172,87): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(215,67): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(224,82): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(230,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(231,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(232,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(235,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(237,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(239,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(239,71): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(239,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(242,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(244,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts (40 errors) ==== - class privateClass { } diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.js b/tests/baselines/reference/privacyFunctionParameterDeclFile.js index 255b8d68db6a2..db00fb67d8a21 100644 --- a/tests/baselines/reference/privacyFunctionParameterDeclFile.js +++ b/tests/baselines/reference/privacyFunctionParameterDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyFunctionParameterDeclFile.ts] //// //// [privacyFunctionParameterDeclFile_externalModule.ts] - class privateClass { } diff --git a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt index 0156c7241f778..94c8b20311ca4 100644 --- a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt +++ b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt @@ -20,54 +20,53 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(462,9): err tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(466,70): error TS4060: Return type of exported function has or is using private name 'privateModule'. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(469,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(472,85): error TS4060: Return type of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(9,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(10,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(11,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(12,17): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(37,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(43,23): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(49,12): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(55,5): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(144,59): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(156,17): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(169,74): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(175,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(176,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(177,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(178,17): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(181,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(184,23): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(187,12): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(190,5): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(194,66): error TS4060: Return type of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(197,17): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(200,81): error TS4060: Return type of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(238,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(239,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(240,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(241,21): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(266,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(272,27): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(278,16): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(284,9): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(373,63): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(385,21): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(398,78): error TS4060: Return type of exported function has or is using private name 'privateClass'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(404,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(405,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(406,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(407,21): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(410,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(413,27): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(416,16): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(419,9): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(423,70): error TS4060: Return type of exported function has or is using private name 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(426,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. -tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85): error TS4060: Return type of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(8,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(9,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(10,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(11,17): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(36,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(42,23): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(48,12): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(54,5): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(143,59): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(155,17): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(168,74): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(174,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(175,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(176,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(177,17): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(180,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(183,23): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(186,12): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(189,5): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(193,66): error TS4060: Return type of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(196,17): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(199,81): error TS4060: Return type of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(237,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(238,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(239,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(240,21): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(265,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(271,27): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(277,16): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(283,9): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(372,63): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(384,21): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(397,78): error TS4060: Return type of exported function has or is using private name 'privateClass'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(403,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(404,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(405,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(406,21): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(409,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(412,27): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(415,16): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(418,9): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(422,70): error TS4060: Return type of exported function has or is using private name 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(425,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(428,85): error TS4060: Return type of exported function has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts (44 errors) ==== - class privateClass { } diff --git a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.js b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.js index 1aba74efaa49f..d3136f4310ed3 100644 --- a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.js +++ b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyFunctionReturnTypeDeclFile.ts] //// //// [privacyFunctionReturnTypeDeclFile_externalModule.ts] - class privateClass { } diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt index 2107e77317384..0669d3c3d2647 100644 --- a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt +++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt @@ -1,13 +1,12 @@ tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts(14,82): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(15,82): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(20,84): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(23,83): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(63,70): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterface' has or is using private name 'privateInterface'. -tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,80): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(14,82): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(19,84): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(22,83): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(62,70): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterface' has or is using private name 'privateInterface'. +tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(67,80): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts (5 errors) ==== - export module publicModule { export interface publicInterfaceInPublicModule { } diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js index 6d2748dd8dccd..cb25b2b5ff93b 100644 --- a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js +++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile.ts] //// //// [privacyInterfaceExtendsClauseDeclFile_externalModule.ts] - export module publicModule { export interface publicInterfaceInPublicModule { } diff --git a/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.errors.txt b/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.errors.txt index cc81762bce374..c657347043f2b 100644 --- a/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.errors.txt +++ b/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.errors.txt @@ -26,7 +26,6 @@ tests/cases/compiler/privacyTopLevelAmbientExternalModuleImportWithoutExport_cor !!! error TS2323: Cannot redeclare exported variable 'publicUse_im_private_mi_public'. ==== tests/cases/compiler/privacyTopLevelAmbientExternalModuleImportWithoutExport_require.ts (0 errors) ==== - // Public elements export class c_public { foo: string; diff --git a/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.js b/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.js index 13b7de58ecff6..de464ddd11a6a 100644 --- a/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.js +++ b/tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyTopLevelAmbientExternalModuleImportWithoutExport.ts] //// //// [privacyTopLevelAmbientExternalModuleImportWithoutExport_require.ts] - // Public elements export class c_public { foo: string; diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt index 1fbf8f7bac94b..d7f8e5abc0100 100644 --- a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt +++ b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(51,31): error TS4000: Import declaration 'im_private_c_private' is using private name 'm_private'. -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(52,31): error TS4000: Import declaration 'im_private_e_private' is using private name 'm_private'. -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(55,31): error TS4000: Import declaration 'im_private_i_private' is using private name 'm_private'. -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(56,32): error TS4000: Import declaration 'im_private_mi_private' is using private name 'm_private'. -tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(57,32): error TS4000: Import declaration 'im_private_mu_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(50,31): error TS4000: Import declaration 'im_private_c_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(51,31): error TS4000: Import declaration 'im_private_e_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(54,31): error TS4000: Import declaration 'im_private_i_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(55,32): error TS4000: Import declaration 'im_private_mi_private' is using private name 'm_private'. +tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(56,32): error TS4000: Import declaration 'im_private_mu_private' is using private name 'm_private'. ==== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts (5 errors) ==== - // private elements module m_private { export class c_private { diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.js b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.js index 85a6cc3691a43..8646cbe6f7583 100644 --- a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.js +++ b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.js @@ -1,5 +1,4 @@ //// [privacyTopLevelInternalReferenceImportWithoutExport.ts] - // private elements module m_private { export class c_private { diff --git a/tests/baselines/reference/privacyVarDeclFile.errors.txt b/tests/baselines/reference/privacyVarDeclFile.errors.txt index 6ae5373e0c7f7..c6ee30d663070 100644 --- a/tests/baselines/reference/privacyVarDeclFile.errors.txt +++ b/tests/baselines/reference/privacyVarDeclFile.errors.txt @@ -8,30 +8,29 @@ tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(162,40): error TS4028: Pub tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(163,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(165,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(166,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(9,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(25,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(27,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(52,47): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(57,62): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(63,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(66,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(67,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(69,53): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(70,68): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(90,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(106,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(108,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(133,51): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(138,66): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(144,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(147,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(148,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(150,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. -tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(8,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(24,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(26,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(51,47): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(56,62): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(62,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(65,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(66,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(68,53): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(69,68): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(89,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(105,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(107,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(132,51): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(137,66): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(143,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(146,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(147,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(149,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. +tests/cases/compiler/privacyVarDeclFile_externalModule.ts(150,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'. ==== tests/cases/compiler/privacyVarDeclFile_externalModule.ts (20 errors) ==== - class privateClass { } diff --git a/tests/baselines/reference/privacyVarDeclFile.js b/tests/baselines/reference/privacyVarDeclFile.js index eab997478494d..b32fac91085d9 100644 --- a/tests/baselines/reference/privacyVarDeclFile.js +++ b/tests/baselines/reference/privacyVarDeclFile.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/privacyVarDeclFile.ts] //// //// [privacyVarDeclFile_externalModule.ts] - class privateClass { } diff --git a/tests/baselines/reference/promisePermutations.errors.txt b/tests/baselines/reference/promisePermutations.errors.txt index 69bd8c1e629d0..e5e7f2109a963 100644 --- a/tests/baselines/reference/promisePermutations.errors.txt +++ b/tests/baselines/reference/promisePermutations.errors.txt @@ -44,10 +44,8 @@ tests/cases/compiler/promisePermutations.ts(133,19): error TS2345: Argument of t tests/cases/compiler/promisePermutations.ts(134,19): error TS2345: Argument of type '(x: T, cb: (a: U) => U) => Promise' is not assignable to parameter of type '(value: number) => IPromise'. tests/cases/compiler/promisePermutations.ts(137,11): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. - Type 'string' is not assignable to type 'number'. tests/cases/compiler/promisePermutations.ts(144,12): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. - Type 'string' is not assignable to type 'number'. tests/cases/compiler/promisePermutations.ts(152,12): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'Promise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. Types of property 'then' are incompatible. @@ -61,7 +59,6 @@ tests/cases/compiler/promisePermutations.ts(156,21): error TS2345: Argument of t Type 'number' is not assignable to type 'string'. tests/cases/compiler/promisePermutations.ts(158,21): error TS2345: Argument of type '{ (x: number): IPromise; (x: string): IPromise; }' is not assignable to parameter of type '(value: number) => IPromise'. Type 'IPromise' is not assignable to type 'IPromise'. - Type 'number' is not assignable to type 'string'. tests/cases/compiler/promisePermutations.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'string'. @@ -286,7 +283,6 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of t ~~~~~~~ !!! error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. !!! error TS2453: Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. -!!! error TS2453: Type 'string' is not assignable to type 'number'. var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok var r10 = testFunction10(x => x); @@ -297,7 +293,6 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of t ~~~~~~~~ !!! error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. !!! error TS2453: Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. -!!! error TS2453: Type 'string' is not assignable to type 'number'. var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok var s10 = testFunction10P(x => x); var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok @@ -328,7 +323,6 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of t ~~~~~~~~~~~~~~ !!! error TS2345: Argument of type '{ (x: number): IPromise; (x: string): IPromise; }' is not assignable to parameter of type '(value: number) => IPromise'. !!! error TS2345: Type 'IPromise' is not assignable to type 'IPromise'. -!!! error TS2345: Type 'number' is not assignable to type 'string'. var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error ~~~~~~~~~~~~~~~ !!! error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => Promise'. diff --git a/tests/baselines/reference/promisePermutations2.errors.txt b/tests/baselines/reference/promisePermutations2.errors.txt index cbbd9cc77366a..26fec6b2fd118 100644 --- a/tests/baselines/reference/promisePermutations2.errors.txt +++ b/tests/baselines/reference/promisePermutations2.errors.txt @@ -44,10 +44,8 @@ tests/cases/compiler/promisePermutations2.ts(132,19): error TS2345: Argument of tests/cases/compiler/promisePermutations2.ts(133,19): error TS2345: Argument of type '(x: T, cb: (a: U) => U) => Promise' is not assignable to parameter of type '(value: number) => IPromise'. tests/cases/compiler/promisePermutations2.ts(136,11): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. - Type 'string' is not assignable to type 'number'. tests/cases/compiler/promisePermutations2.ts(143,12): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. - Type 'string' is not assignable to type 'number'. tests/cases/compiler/promisePermutations2.ts(151,12): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'Promise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. Types of property 'then' are incompatible. @@ -61,7 +59,6 @@ tests/cases/compiler/promisePermutations2.ts(155,21): error TS2345: Argument of Type 'number' is not assignable to type 'string'. tests/cases/compiler/promisePermutations2.ts(157,21): error TS2345: Argument of type '{ (x: number): IPromise; (x: string): IPromise; }' is not assignable to parameter of type '(value: number) => IPromise'. Type 'IPromise' is not assignable to type 'IPromise'. - Type 'number' is not assignable to type 'string'. tests/cases/compiler/promisePermutations2.ts(158,21): error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'string'. @@ -285,7 +282,6 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of ~~~~~~~ !!! error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. !!! error TS2453: Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. -!!! error TS2453: Type 'string' is not assignable to type 'number'. var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok var r10 = testFunction10(x => x); @@ -296,7 +292,6 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of ~~~~~~~~ !!! error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. !!! error TS2453: Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. -!!! error TS2453: Type 'string' is not assignable to type 'number'. var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok var s10 = testFunction10P(x => x); var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok @@ -327,7 +322,6 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of ~~~~~~~~~~~~~~ !!! error TS2345: Argument of type '{ (x: number): IPromise; (x: string): IPromise; }' is not assignable to parameter of type '(value: number) => IPromise'. !!! error TS2345: Type 'IPromise' is not assignable to type 'IPromise'. -!!! error TS2345: Type 'number' is not assignable to type 'string'. var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok ~~~~~~~~~~~~~~~ !!! error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => Promise'. diff --git a/tests/baselines/reference/promisePermutations3.errors.txt b/tests/baselines/reference/promisePermutations3.errors.txt index fd0ce0d643eab..1354f486fcb26 100644 --- a/tests/baselines/reference/promisePermutations3.errors.txt +++ b/tests/baselines/reference/promisePermutations3.errors.txt @@ -47,10 +47,8 @@ tests/cases/compiler/promisePermutations3.ts(132,19): error TS2345: Argument of tests/cases/compiler/promisePermutations3.ts(133,19): error TS2345: Argument of type '(x: T, cb: (a: U) => U) => Promise' is not assignable to parameter of type '(value: number) => IPromise'. tests/cases/compiler/promisePermutations3.ts(136,11): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. - Type 'string' is not assignable to type 'number'. tests/cases/compiler/promisePermutations3.ts(143,12): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. - Type 'string' is not assignable to type 'number'. tests/cases/compiler/promisePermutations3.ts(151,12): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate 'Promise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. Types of property 'then' are incompatible. @@ -64,7 +62,6 @@ tests/cases/compiler/promisePermutations3.ts(155,21): error TS2345: Argument of Type 'number' is not assignable to type 'string'. tests/cases/compiler/promisePermutations3.ts(157,21): error TS2345: Argument of type '{ (x: number): IPromise; (x: string): IPromise; }' is not assignable to parameter of type '(value: number) => IPromise'. Type 'IPromise' is not assignable to type 'IPromise'. - Type 'number' is not assignable to type 'string'. tests/cases/compiler/promisePermutations3.ts(158,21): error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => Promise'. Type 'Promise' is not assignable to type 'Promise'. Type 'number' is not assignable to type 'string'. @@ -297,7 +294,6 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of ~~~~~~~ !!! error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. !!! error TS2453: Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. -!!! error TS2453: Type 'string' is not assignable to type 'number'. var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok var r10 = testFunction10(x => x); @@ -308,7 +304,6 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of ~~~~~~~~ !!! error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly. !!! error TS2453: Type argument candidate 'IPromise' is not a valid type argument because it is not a supertype of candidate 'IPromise'. -!!! error TS2453: Type 'string' is not assignable to type 'number'. var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok var s10 = testFunction10P(x => x); var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok @@ -339,7 +334,6 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of ~~~~~~~~~~~~~~ !!! error TS2345: Argument of type '{ (x: number): IPromise; (x: string): IPromise; }' is not assignable to parameter of type '(value: number) => IPromise'. !!! error TS2345: Type 'IPromise' is not assignable to type 'IPromise'. -!!! error TS2345: Type 'number' is not assignable to type 'string'. var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error ~~~~~~~~~~~~~~~ !!! error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => Promise'. diff --git a/tests/baselines/reference/promiseTest.js b/tests/baselines/reference/promiseTest.js index db5541974990e..dcac778aff6ae 100644 --- a/tests/baselines/reference/promiseTest.js +++ b/tests/baselines/reference/promiseTest.js @@ -1,5 +1,4 @@ //// [promiseTest.ts] - interface Promise { then(success?: (value: T) => Promise): Promise; then(success?: (value: T) => B): Promise; diff --git a/tests/baselines/reference/promiseTest.symbols b/tests/baselines/reference/promiseTest.symbols index f28348cca45d4..4030f122a61b9 100644 --- a/tests/baselines/reference/promiseTest.symbols +++ b/tests/baselines/reference/promiseTest.symbols @@ -1,55 +1,54 @@ === tests/cases/compiler/promiseTest.ts === - interface Promise { >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 18)) then(success?: (value: T) => Promise): Promise; ->then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60)) ->A : Symbol(A, Decl(promiseTest.ts, 2, 9)) ->success : Symbol(success, Decl(promiseTest.ts, 2, 12)) ->value : Symbol(value, Decl(promiseTest.ts, 2, 23)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18)) +>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 22), Decl(promiseTest.ts, 1, 60)) +>A : Symbol(A, Decl(promiseTest.ts, 1, 9)) +>success : Symbol(success, Decl(promiseTest.ts, 1, 12)) +>value : Symbol(value, Decl(promiseTest.ts, 1, 23)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 18)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) ->A : Symbol(A, Decl(promiseTest.ts, 2, 9)) +>A : Symbol(A, Decl(promiseTest.ts, 1, 9)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) ->A : Symbol(A, Decl(promiseTest.ts, 2, 9)) +>A : Symbol(A, Decl(promiseTest.ts, 1, 9)) then(success?: (value: T) => B): Promise; ->then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60)) ->B : Symbol(B, Decl(promiseTest.ts, 3, 9)) ->success : Symbol(success, Decl(promiseTest.ts, 3, 12)) ->value : Symbol(value, Decl(promiseTest.ts, 3, 23)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18)) ->B : Symbol(B, Decl(promiseTest.ts, 3, 9)) +>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 22), Decl(promiseTest.ts, 1, 60)) +>B : Symbol(B, Decl(promiseTest.ts, 2, 9)) +>success : Symbol(success, Decl(promiseTest.ts, 2, 12)) +>value : Symbol(value, Decl(promiseTest.ts, 2, 23)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 18)) +>B : Symbol(B, Decl(promiseTest.ts, 2, 9)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) ->B : Symbol(B, Decl(promiseTest.ts, 3, 9)) +>B : Symbol(B, Decl(promiseTest.ts, 2, 9)) data: T; ->data : Symbol(Promise.data, Decl(promiseTest.ts, 3, 51)) ->T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18)) +>data : Symbol(Promise.data, Decl(promiseTest.ts, 2, 51)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 18)) } var p: Promise = null; ->p : Symbol(p, Decl(promiseTest.ts, 7, 3)) +>p : Symbol(p, Decl(promiseTest.ts, 6, 3)) >Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0)) var p2 = p.then(function (x) { ->p2 : Symbol(p2, Decl(promiseTest.ts, 8, 3)) ->p.then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60)) ->p : Symbol(p, Decl(promiseTest.ts, 7, 3)) ->then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60)) ->x : Symbol(x, Decl(promiseTest.ts, 8, 26)) +>p2 : Symbol(p2, Decl(promiseTest.ts, 7, 3)) +>p.then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 22), Decl(promiseTest.ts, 1, 60)) +>p : Symbol(p, Decl(promiseTest.ts, 6, 3)) +>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 22), Decl(promiseTest.ts, 1, 60)) +>x : Symbol(x, Decl(promiseTest.ts, 7, 26)) return p; ->p : Symbol(p, Decl(promiseTest.ts, 7, 3)) +>p : Symbol(p, Decl(promiseTest.ts, 6, 3)) } ); var x = p2.data; // number ->x : Symbol(x, Decl(promiseTest.ts, 12, 3)) ->p2.data : Symbol(Promise.data, Decl(promiseTest.ts, 3, 51)) ->p2 : Symbol(p2, Decl(promiseTest.ts, 8, 3)) ->data : Symbol(Promise.data, Decl(promiseTest.ts, 3, 51)) +>x : Symbol(x, Decl(promiseTest.ts, 11, 3)) +>p2.data : Symbol(Promise.data, Decl(promiseTest.ts, 2, 51)) +>p2 : Symbol(p2, Decl(promiseTest.ts, 7, 3)) +>data : Symbol(Promise.data, Decl(promiseTest.ts, 2, 51)) diff --git a/tests/baselines/reference/promiseTest.types b/tests/baselines/reference/promiseTest.types index d69e1efeb42c7..b9166a1af25d4 100644 --- a/tests/baselines/reference/promiseTest.types +++ b/tests/baselines/reference/promiseTest.types @@ -1,5 +1,4 @@ === tests/cases/compiler/promiseTest.ts === - interface Promise { >Promise : Promise >T : T diff --git a/tests/baselines/reference/properties.js b/tests/baselines/reference/properties.js index fc10342352963..70bb62dd09d54 100644 --- a/tests/baselines/reference/properties.js +++ b/tests/baselines/reference/properties.js @@ -1,5 +1,4 @@ //// [properties.ts] - class MyClass { public get Count(): number diff --git a/tests/baselines/reference/properties.js.map b/tests/baselines/reference/properties.js.map index b9820ddba7c6e..47c17f796c988 100644 --- a/tests/baselines/reference/properties.js.map +++ b/tests/baselines/reference/properties.js.map @@ -1,2 +1,2 @@ //// [properties.js.map] -{"version":3,"file":"properties.js","sourceRoot":"","sources":["properties.ts"],"names":[],"mappings":"AACA;IAAA;IAWA,CAAC;IATG,sBAAW,0BAAK;aAAhB;YAEI,MAAM,CAAC,EAAE,CAAC;QACd,CAAC;aAED,UAAiB,KAAa;YAE1B,EAAE;QACN,CAAC;;;OALA;IAML,cAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file +{"version":3,"file":"properties.js","sourceRoot":"","sources":["properties.ts"],"names":[],"mappings":"AAAA;IAAA;IAWA,CAAC;IATG,sBAAW,0BAAK;aAAhB;YAEI,MAAM,CAAC,EAAE,CAAC;QACd,CAAC;aAED,UAAiB,KAAa;YAE1B,EAAE;QACN,CAAC;;;OALA;IAML,cAAC;AAAD,CAAC,AAXD,IAWC"} \ No newline at end of file diff --git a/tests/baselines/reference/properties.sourcemap.txt b/tests/baselines/reference/properties.sourcemap.txt index 8c99154125a47..0afa8514e6636 100644 --- a/tests/baselines/reference/properties.sourcemap.txt +++ b/tests/baselines/reference/properties.sourcemap.txt @@ -11,15 +11,14 @@ sourceFile:properties.ts >>>var MyClass = (function () { 1 > 2 >^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +1 > +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) --- >>> function MyClass() { 1->^^^^ 2 > ^^-> 1-> -1->Emitted(2, 5) Source(2, 1) + SourceIndex(0) +1->Emitted(2, 5) Source(1, 1) + SourceIndex(0) --- >>> } 1->^^^^ @@ -38,8 +37,8 @@ sourceFile:properties.ts > } > 2 > } -1->Emitted(3, 5) Source(13, 1) + SourceIndex(0) -2 >Emitted(3, 6) Source(13, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(12, 1) + SourceIndex(0) +2 >Emitted(3, 6) Source(12, 2) + SourceIndex(0) --- >>> Object.defineProperty(MyClass.prototype, "Count", { 1->^^^^ @@ -48,15 +47,15 @@ sourceFile:properties.ts 1-> 2 > public get 3 > Count -1->Emitted(4, 5) Source(4, 5) + SourceIndex(0) -2 >Emitted(4, 27) Source(4, 16) + SourceIndex(0) -3 >Emitted(4, 53) Source(4, 21) + SourceIndex(0) +1->Emitted(4, 5) Source(3, 5) + SourceIndex(0) +2 >Emitted(4, 27) Source(3, 16) + SourceIndex(0) +3 >Emitted(4, 53) Source(3, 21) + SourceIndex(0) --- >>> get: function () { 1 >^^^^^^^^^^^^^ 2 > ^^^^^^^^^^-> 1 > -1 >Emitted(5, 14) Source(4, 5) + SourceIndex(0) +1 >Emitted(5, 14) Source(3, 5) + SourceIndex(0) --- >>> return 42; 1->^^^^^^^^^^^^ @@ -71,11 +70,11 @@ sourceFile:properties.ts 3 > 4 > 42 5 > ; -1->Emitted(6, 13) Source(6, 9) + SourceIndex(0) -2 >Emitted(6, 19) Source(6, 15) + SourceIndex(0) -3 >Emitted(6, 20) Source(6, 16) + SourceIndex(0) -4 >Emitted(6, 22) Source(6, 18) + SourceIndex(0) -5 >Emitted(6, 23) Source(6, 19) + SourceIndex(0) +1->Emitted(6, 13) Source(5, 9) + SourceIndex(0) +2 >Emitted(6, 19) Source(5, 15) + SourceIndex(0) +3 >Emitted(6, 20) Source(5, 16) + SourceIndex(0) +4 >Emitted(6, 22) Source(5, 18) + SourceIndex(0) +5 >Emitted(6, 23) Source(5, 19) + SourceIndex(0) --- >>> }, 1 >^^^^^^^^ @@ -84,8 +83,8 @@ sourceFile:properties.ts 1 > > 2 > } -1 >Emitted(7, 9) Source(7, 5) + SourceIndex(0) -2 >Emitted(7, 10) Source(7, 6) + SourceIndex(0) +1 >Emitted(7, 9) Source(6, 5) + SourceIndex(0) +2 >Emitted(7, 10) Source(6, 6) + SourceIndex(0) --- >>> set: function (value) { 1->^^^^^^^^^^^^^ @@ -96,9 +95,9 @@ sourceFile:properties.ts > 2 > public set Count( 3 > value: number -1->Emitted(8, 14) Source(9, 5) + SourceIndex(0) -2 >Emitted(8, 24) Source(9, 22) + SourceIndex(0) -3 >Emitted(8, 29) Source(9, 35) + SourceIndex(0) +1->Emitted(8, 14) Source(8, 5) + SourceIndex(0) +2 >Emitted(8, 24) Source(8, 22) + SourceIndex(0) +3 >Emitted(8, 29) Source(8, 35) + SourceIndex(0) --- >>> // 1 >^^^^^^^^^^^^ @@ -107,8 +106,8 @@ sourceFile:properties.ts > { > 2 > // -1 >Emitted(9, 13) Source(11, 9) + SourceIndex(0) -2 >Emitted(9, 15) Source(11, 11) + SourceIndex(0) +1 >Emitted(9, 13) Source(10, 9) + SourceIndex(0) +2 >Emitted(9, 15) Source(10, 11) + SourceIndex(0) --- >>> }, 1 >^^^^^^^^ @@ -117,8 +116,8 @@ sourceFile:properties.ts 1 > > 2 > } -1 >Emitted(10, 9) Source(12, 5) + SourceIndex(0) -2 >Emitted(10, 10) Source(12, 6) + SourceIndex(0) +1 >Emitted(10, 9) Source(11, 5) + SourceIndex(0) +2 >Emitted(10, 10) Source(11, 6) + SourceIndex(0) --- >>> enumerable: true, >>> configurable: true @@ -126,7 +125,7 @@ sourceFile:properties.ts 1->^^^^^^^ 2 > ^^^^^^^^^^^^^-> 1-> -1->Emitted(13, 8) Source(7, 6) + SourceIndex(0) +1->Emitted(13, 8) Source(6, 6) + SourceIndex(0) --- >>> return MyClass; 1->^^^^ @@ -139,8 +138,8 @@ sourceFile:properties.ts > } > 2 > } -1->Emitted(14, 5) Source(13, 1) + SourceIndex(0) -2 >Emitted(14, 19) Source(13, 2) + SourceIndex(0) +1->Emitted(14, 5) Source(12, 1) + SourceIndex(0) +2 >Emitted(14, 19) Source(12, 2) + SourceIndex(0) --- >>>}()); 1 > @@ -163,9 +162,9 @@ sourceFile:properties.ts > // > } > } -1 >Emitted(15, 1) Source(13, 1) + SourceIndex(0) -2 >Emitted(15, 2) Source(13, 2) + SourceIndex(0) -3 >Emitted(15, 2) Source(2, 1) + SourceIndex(0) -4 >Emitted(15, 6) Source(13, 2) + SourceIndex(0) +1 >Emitted(15, 1) Source(12, 1) + SourceIndex(0) +2 >Emitted(15, 2) Source(12, 2) + SourceIndex(0) +3 >Emitted(15, 2) Source(1, 1) + SourceIndex(0) +4 >Emitted(15, 6) Source(12, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=properties.js.map \ No newline at end of file diff --git a/tests/baselines/reference/properties.symbols b/tests/baselines/reference/properties.symbols index c322e5ecfb2db..06980901d131b 100644 --- a/tests/baselines/reference/properties.symbols +++ b/tests/baselines/reference/properties.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/properties.ts === - class MyClass >MyClass : Symbol(MyClass, Decl(properties.ts, 0, 0)) { public get Count(): number ->Count : Symbol(MyClass.Count, Decl(properties.ts, 2, 1), Decl(properties.ts, 6, 5)) +>Count : Symbol(MyClass.Count, Decl(properties.ts, 1, 1), Decl(properties.ts, 5, 5)) { return 42; } public set Count(value: number) ->Count : Symbol(MyClass.Count, Decl(properties.ts, 2, 1), Decl(properties.ts, 6, 5)) ->value : Symbol(value, Decl(properties.ts, 8, 21)) +>Count : Symbol(MyClass.Count, Decl(properties.ts, 1, 1), Decl(properties.ts, 5, 5)) +>value : Symbol(value, Decl(properties.ts, 7, 21)) { // } diff --git a/tests/baselines/reference/properties.types b/tests/baselines/reference/properties.types index 99ff875a0878e..f7440709cd7ce 100644 --- a/tests/baselines/reference/properties.types +++ b/tests/baselines/reference/properties.types @@ -1,5 +1,4 @@ === tests/cases/compiler/properties.ts === - class MyClass >MyClass : MyClass { diff --git a/tests/baselines/reference/propertyAssignment.errors.txt b/tests/baselines/reference/propertyAssignment.errors.txt index a8411ca490c34..6aa34c15ac90e 100644 --- a/tests/baselines/reference/propertyAssignment.errors.txt +++ b/tests/baselines/reference/propertyAssignment.errors.txt @@ -1,14 +1,12 @@ -tests/cases/compiler/propertyAssignment.ts(6,13): error TS1170: A computed property name in a type literal must directly refer to a built-in symbol. -tests/cases/compiler/propertyAssignment.ts(6,14): error TS2304: Cannot find name 'index'. -tests/cases/compiler/propertyAssignment.ts(14,1): error TS2322: Type '{ x: number; }' is not assignable to type 'new () => any'. +tests/cases/compiler/propertyAssignment.ts(4,13): error TS1170: A computed property name in a type literal must directly refer to a built-in symbol. +tests/cases/compiler/propertyAssignment.ts(4,14): error TS2304: Cannot find name 'index'. +tests/cases/compiler/propertyAssignment.ts(12,1): error TS2322: Type '{ x: number; }' is not assignable to type 'new () => any'. Type '{ x: number; }' provides no match for the signature 'new (): any'. -tests/cases/compiler/propertyAssignment.ts(16,1): error TS2322: Type '{ x: number; }' is not assignable to type '() => void'. +tests/cases/compiler/propertyAssignment.ts(14,1): error TS2322: Type '{ x: number; }' is not assignable to type '() => void'. Type '{ x: number; }' provides no match for the signature '(): void'. ==== tests/cases/compiler/propertyAssignment.ts (4 errors) ==== - - var foo1: { new ():any; } var bar1: { x : number; } diff --git a/tests/baselines/reference/propertyAssignment.js b/tests/baselines/reference/propertyAssignment.js index 9aa99c8b56113..979d0afc9c328 100644 --- a/tests/baselines/reference/propertyAssignment.js +++ b/tests/baselines/reference/propertyAssignment.js @@ -1,6 +1,4 @@ //// [propertyAssignment.ts] - - var foo1: { new ():any; } var bar1: { x : number; } diff --git a/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.errors.txt b/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.errors.txt index 0bf38477f70bb..de11681331bbd 100644 --- a/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.errors.txt +++ b/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAccessibleWithinNestedSubclass.ts(25,28): error TS2339: Property 'z' does not exist on type 'C'. +tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAccessibleWithinNestedSubclass.ts(24,28): error TS2339: Property 'z' does not exist on type 'C'. ==== tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAccessibleWithinNestedSubclass.ts (1 errors) ==== - class B { protected x: string; protected static x: string; diff --git a/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.js b/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.js index 47d329909fdab..f15f9a5b669a3 100644 --- a/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.js +++ b/tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.js @@ -1,5 +1,4 @@ //// [protectedClassPropertyAccessibleWithinNestedSubclass.ts] - class B { protected x: string; protected static x: string; diff --git a/tests/baselines/reference/protoAssignment.errors.txt b/tests/baselines/reference/protoAssignment.errors.txt index 37c443ba74e70..5a46a96b33d19 100644 --- a/tests/baselines/reference/protoAssignment.errors.txt +++ b/tests/baselines/reference/protoAssignment.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/protoAssignment.ts(2,26): error TS2304: Cannot find name 'Comparable'. +tests/cases/compiler/protoAssignment.ts(1,26): error TS2304: Cannot find name 'Comparable'. ==== tests/cases/compiler/protoAssignment.ts (1 errors) ==== - interface Number extends Comparable { ~~~~~~~~~~ !!! error TS2304: Cannot find name 'Comparable'. diff --git a/tests/baselines/reference/protoAssignment.js b/tests/baselines/reference/protoAssignment.js index a1fe983d29604..5b5c822e5670d 100644 --- a/tests/baselines/reference/protoAssignment.js +++ b/tests/baselines/reference/protoAssignment.js @@ -1,5 +1,4 @@ //// [protoAssignment.ts] - interface Number extends Comparable { compareTo(other: number); diff --git a/tests/baselines/reference/quickInfoDisplayPartsArrowFunctionExpression.baseline b/tests/baselines/reference/quickInfoDisplayPartsArrowFunctionExpression.baseline index 7ee4e5b25cd93..f4484663b97c1 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsArrowFunctionExpression.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsArrowFunctionExpression.baseline @@ -73,7 +73,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -122,7 +123,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -223,7 +225,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -272,7 +275,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -321,7 +325,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -398,7 +403,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -447,7 +453,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -508,7 +515,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsClass.baseline b/tests/baselines/reference/quickInfoDisplayPartsClass.baseline index 0b048b737a62e..68e3b16c7a6f5 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsClass.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsClass.baseline @@ -25,7 +25,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -66,7 +67,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -115,7 +117,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -164,7 +167,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -193,7 +197,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsClassAccessors.baseline b/tests/baselines/reference/quickInfoDisplayPartsClassAccessors.baseline index b0c27fd9d288a..97f167fdd8016 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsClassAccessors.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsClassAccessors.baseline @@ -53,7 +53,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -110,7 +111,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -167,7 +169,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -224,7 +227,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -281,7 +285,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -338,7 +343,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -395,7 +401,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -452,7 +459,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -509,7 +517,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -566,7 +575,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -623,7 +633,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -680,7 +691,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -737,7 +749,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -794,7 +807,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -851,7 +865,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -908,7 +923,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -965,7 +981,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1022,7 +1039,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1079,7 +1097,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1136,7 +1155,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1193,7 +1213,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1250,7 +1271,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1307,7 +1329,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1364,7 +1387,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1405,7 +1429,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1462,7 +1487,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1491,7 +1517,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1548,7 +1575,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1589,7 +1617,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1646,7 +1675,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1675,7 +1705,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1732,7 +1763,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsClassConstructor.baseline b/tests/baselines/reference/quickInfoDisplayPartsClassConstructor.baseline index 76ca00a4048d4..f6217460180b4 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsClassConstructor.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsClassConstructor.baseline @@ -45,7 +45,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -86,7 +87,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -135,7 +137,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -184,7 +187,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -213,7 +217,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -306,7 +311,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -399,7 +405,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -492,7 +499,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -533,7 +541,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -626,7 +635,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -667,7 +677,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -760,7 +771,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -809,7 +821,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -838,7 +851,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -931,7 +945,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1024,7 +1039,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1117,7 +1133,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1210,7 +1227,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1251,7 +1269,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1344,7 +1363,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1385,7 +1405,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1478,7 +1499,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1519,7 +1541,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1612,7 +1635,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1661,7 +1685,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1690,7 +1715,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsClassMethod.baseline b/tests/baselines/reference/quickInfoDisplayPartsClassMethod.baseline index d6f3f187d02cf..e17708f1bc6ec 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsClassMethod.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsClassMethod.baseline @@ -61,7 +61,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -126,7 +127,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -191,7 +193,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -256,7 +259,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -321,7 +325,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -386,7 +391,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -451,7 +457,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -516,7 +523,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -581,7 +589,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -646,7 +655,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -711,7 +721,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -776,7 +787,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -817,7 +829,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -882,7 +895,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -911,7 +925,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -976,7 +991,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsClassProperty.baseline b/tests/baselines/reference/quickInfoDisplayPartsClassProperty.baseline index b49fb80c38a91..57a41e6beb4f3 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsClassProperty.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsClassProperty.baseline @@ -53,7 +53,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -110,7 +111,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -167,7 +169,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -224,7 +227,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -281,7 +285,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -338,7 +343,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -395,7 +401,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -452,7 +459,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -509,7 +517,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -566,7 +575,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -623,7 +633,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -680,7 +691,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -721,7 +733,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -778,7 +791,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -807,7 +821,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -864,7 +879,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsConst.baseline b/tests/baselines/reference/quickInfoDisplayPartsConst.baseline index 7493d001bd394..f73ef50dc0cf9 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsConst.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsConst.baseline @@ -37,7 +37,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -78,7 +79,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -119,7 +121,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -160,7 +163,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -201,7 +205,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -250,7 +255,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -291,7 +297,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -352,7 +359,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -413,7 +421,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -474,7 +483,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -535,7 +545,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -680,7 +691,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -825,7 +837,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -970,7 +983,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1075,7 +1089,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1180,7 +1195,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsEnum1.baseline b/tests/baselines/reference/quickInfoDisplayPartsEnum1.baseline index 6dc27a4a5b33d..cf3ddc3025c2d 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsEnum1.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsEnum1.baseline @@ -25,7 +25,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -86,7 +87,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -147,7 +149,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -208,7 +211,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -249,7 +253,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -278,7 +283,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -319,7 +325,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -348,7 +355,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -409,7 +417,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -450,7 +459,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -479,7 +489,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -540,7 +551,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -581,7 +593,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -610,7 +623,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -671,7 +685,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -708,7 +723,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -769,7 +785,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -830,7 +847,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -891,7 +909,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -932,7 +951,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -969,7 +989,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1010,7 +1031,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1047,7 +1069,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1108,7 +1131,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1149,7 +1173,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1186,7 +1211,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1247,7 +1273,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1288,7 +1315,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1325,7 +1353,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1386,7 +1415,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsEnum2.baseline b/tests/baselines/reference/quickInfoDisplayPartsEnum2.baseline index 43d0683faef80..0bb72e51078bf 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsEnum2.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsEnum2.baseline @@ -25,7 +25,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -90,7 +91,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -155,7 +157,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -220,7 +223,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -261,7 +265,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -290,7 +295,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -331,7 +337,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -360,7 +367,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -425,7 +433,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -466,7 +475,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -495,7 +505,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -560,7 +571,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -601,7 +613,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -630,7 +643,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -695,7 +709,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -732,7 +747,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -797,7 +813,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -862,7 +879,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -927,7 +945,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -968,7 +987,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1005,7 +1025,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1046,7 +1067,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1083,7 +1105,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1148,7 +1171,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1189,7 +1213,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1226,7 +1251,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1291,7 +1317,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1332,7 +1359,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1369,7 +1397,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1434,7 +1463,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsEnum3.baseline b/tests/baselines/reference/quickInfoDisplayPartsEnum3.baseline index b9f6483f63ae5..1366a49ec7b4f 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsEnum3.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsEnum3.baseline @@ -25,7 +25,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -90,7 +91,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -155,7 +157,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -220,7 +223,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -261,7 +265,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -290,7 +295,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -331,7 +337,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -360,7 +367,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -425,7 +433,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -466,7 +475,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -495,7 +505,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -560,7 +571,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -601,7 +613,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -630,7 +643,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -695,7 +709,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -732,7 +747,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -797,7 +813,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -862,7 +879,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -927,7 +945,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -968,7 +987,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1005,7 +1025,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1046,7 +1067,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1083,7 +1105,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1148,7 +1171,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1189,7 +1213,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1226,7 +1251,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1291,7 +1317,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1332,7 +1359,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1369,7 +1397,8 @@ "kind": "enumName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1434,7 +1463,8 @@ "kind": "numericLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsExternalModuleAlias_file0.baseline b/tests/baselines/reference/quickInfoDisplayPartsExternalModuleAlias_file0.baseline index 78667e7c6e6f4..182ae0a4040b8 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsExternalModuleAlias_file0.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsExternalModuleAlias_file0.baseline @@ -53,7 +53,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -82,7 +83,8 @@ "kind": "aliasName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -139,7 +141,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -196,7 +199,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -225,7 +229,8 @@ "kind": "aliasName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -282,7 +287,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsExternalModules.baseline b/tests/baselines/reference/quickInfoDisplayPartsExternalModules.baseline index fa548470a762b..dc422bbac33b9 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsExternalModules.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsExternalModules.baseline @@ -25,7 +25,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -66,7 +67,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -115,7 +117,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -164,7 +167,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -193,7 +197,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -242,7 +247,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -271,7 +277,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -300,7 +307,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -337,7 +345,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -378,7 +387,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -435,7 +445,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -492,7 +503,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -521,7 +533,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -558,7 +571,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -615,7 +629,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -644,7 +659,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -681,7 +697,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsFunction.baseline b/tests/baselines/reference/quickInfoDisplayPartsFunction.baseline index 6ac80589629e7..2e3cacb9801b0 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsFunction.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsFunction.baseline @@ -153,7 +153,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -246,7 +247,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -339,7 +341,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -432,7 +435,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -525,7 +529,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -618,7 +623,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -711,7 +717,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -804,7 +811,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -961,7 +969,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1054,7 +1063,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1147,7 +1157,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1240,7 +1251,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1333,7 +1345,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1426,7 +1439,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsFunctionExpression.baseline b/tests/baselines/reference/quickInfoDisplayPartsFunctionExpression.baseline index ec943e3ac7c28..2e67ba6c4aa2f 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsFunctionExpression.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsFunctionExpression.baseline @@ -57,7 +57,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -114,7 +115,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -171,7 +173,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -232,7 +235,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -289,7 +293,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -346,7 +351,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsInterface.baseline b/tests/baselines/reference/quickInfoDisplayPartsInterface.baseline index 43b9faa9540a5..51383489237dd 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsInterface.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsInterface.baseline @@ -25,7 +25,8 @@ "kind": "interfaceName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -66,7 +67,8 @@ "kind": "interfaceName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -95,7 +97,8 @@ "kind": "interfaceName" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsInterfaceMembers.baseline b/tests/baselines/reference/quickInfoDisplayPartsInterfaceMembers.baseline index 170c7ed0bff7e..732582d91905d 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsInterfaceMembers.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsInterfaceMembers.baseline @@ -53,7 +53,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -118,7 +119,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -159,7 +161,8 @@ "kind": "interfaceName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -216,7 +219,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -257,7 +261,8 @@ "kind": "interfaceName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -322,7 +327,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -387,7 +393,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -428,7 +435,8 @@ "kind": "interfaceName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -501,7 +509,8 @@ "kind": "interfaceName" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsLet.baseline b/tests/baselines/reference/quickInfoDisplayPartsLet.baseline index 2153c0b132bab..d8f339f8451ad 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsLet.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsLet.baseline @@ -37,7 +37,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -78,7 +79,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -119,7 +121,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -160,7 +163,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -201,7 +205,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -250,7 +255,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -291,7 +297,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -352,7 +359,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -413,7 +421,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -474,7 +483,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -535,7 +545,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -680,7 +691,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -825,7 +837,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -970,7 +983,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1075,7 +1089,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1180,7 +1195,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsLiteralLikeNames01.baseline b/tests/baselines/reference/quickInfoDisplayPartsLiteralLikeNames01.baseline index 71b971b734022..39ab90e8e09c1 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsLiteralLikeNames01.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsLiteralLikeNames01.baseline @@ -65,7 +65,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -130,7 +131,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -195,7 +197,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -264,7 +267,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -333,7 +337,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -402,7 +407,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -467,7 +473,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -532,7 +539,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -597,7 +605,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -666,7 +675,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsLocalFunction.baseline b/tests/baselines/reference/quickInfoDisplayPartsLocalFunction.baseline index 65c3dc88390cb..1b7d050c3b3e6 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsLocalFunction.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsLocalFunction.baseline @@ -45,7 +45,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -210,7 +211,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -311,7 +313,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -412,7 +415,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -513,7 +517,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -614,7 +619,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -715,7 +721,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -816,7 +823,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -917,7 +925,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1082,7 +1091,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1183,7 +1193,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1284,7 +1295,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1385,7 +1397,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1486,7 +1499,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1587,7 +1601,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1636,7 +1651,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsModules.baseline b/tests/baselines/reference/quickInfoDisplayPartsModules.baseline index e2f04ea75e84b..66c04216af6d2 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsModules.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsModules.baseline @@ -25,7 +25,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -66,7 +67,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -115,7 +117,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -164,7 +167,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -193,7 +197,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -242,7 +247,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -271,7 +277,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -300,7 +307,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -337,7 +345,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -378,7 +387,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -435,7 +445,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -492,7 +503,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -521,7 +533,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -558,7 +571,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -615,7 +629,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -644,7 +659,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -681,7 +697,8 @@ "kind": "moduleName" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsParameters.baseline b/tests/baselines/reference/quickInfoDisplayPartsParameters.baseline index 45f6128c2b117..c0451e35dbbfd 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsParameters.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsParameters.baseline @@ -153,7 +153,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -202,7 +203,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -251,7 +253,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -300,7 +303,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -357,7 +361,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -406,7 +411,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -455,7 +461,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -504,7 +511,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -561,7 +569,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsTypeAlias.baseline b/tests/baselines/reference/quickInfoDisplayPartsTypeAlias.baseline index 49a97ac677374..367acd4dbc4d4 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsTypeAlias.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsTypeAlias.baseline @@ -25,7 +25,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -70,7 +71,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -99,7 +101,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -140,7 +143,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -185,7 +189,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -234,7 +239,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInClass.baseline b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInClass.baseline index 48bd280a1b505..db99590548366 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInClass.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInClass.baseline @@ -37,7 +37,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -102,7 +103,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -191,7 +193,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -240,7 +243,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -305,7 +309,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -434,7 +439,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -579,7 +585,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -628,7 +635,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -773,7 +781,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -822,7 +831,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -887,7 +897,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -936,7 +947,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -989,7 +1001,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1078,7 +1091,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1127,7 +1141,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1168,7 +1183,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1221,7 +1237,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1350,7 +1367,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1419,7 +1437,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1512,7 +1531,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1553,7 +1573,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1670,7 +1691,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1747,7 +1769,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1840,7 +1863,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2025,7 +2049,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2226,7 +2251,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2267,7 +2293,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2344,7 +2371,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2545,7 +2573,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2622,7 +2651,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2715,7 +2745,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2792,7 +2823,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2857,7 +2889,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2982,7 +3015,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3035,7 +3069,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3084,7 +3119,8 @@ "kind": "className" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3153,7 +3189,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3218,7 +3255,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3407,7 +3445,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3460,7 +3499,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3513,7 +3553,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunction.baseline b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunction.baseline index 278e9396fb69c..efe6ccd713060 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunction.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunction.baseline @@ -73,7 +73,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -174,7 +175,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -223,7 +225,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -324,7 +327,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -373,7 +377,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -450,7 +455,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -543,7 +549,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -660,7 +667,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -725,7 +733,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -842,7 +851,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -907,7 +917,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -984,7 +995,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.baseline b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.baseline index 50f0ac16a1cf0..92763ef5b1025 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.baseline @@ -69,7 +69,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -142,7 +143,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -215,7 +217,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInInterface.baseline b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInInterface.baseline index 1306ed9cc97b7..d48bb70f8ffe3 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInInterface.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInInterface.baseline @@ -37,7 +37,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -102,7 +103,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -231,7 +233,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -280,7 +283,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -409,7 +413,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -458,7 +463,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -523,7 +529,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -652,7 +659,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -773,7 +781,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -822,7 +831,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -943,7 +953,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -992,7 +1003,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1057,7 +1069,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1178,7 +1191,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1307,7 +1321,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1452,7 +1467,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1501,7 +1517,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1646,7 +1663,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1695,7 +1713,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1760,7 +1779,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1905,7 +1925,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1958,7 +1979,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1999,7 +2021,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2124,7 +2147,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2241,7 +2265,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2294,7 +2319,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2423,7 +2449,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2492,7 +2519,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2585,7 +2613,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2626,7 +2655,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2783,7 +2813,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2824,7 +2855,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -2901,7 +2933,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3058,7 +3091,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3135,7 +3169,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3228,7 +3263,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3385,7 +3421,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3534,7 +3571,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3575,7 +3613,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3652,7 +3691,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3801,7 +3841,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3878,7 +3919,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -3971,7 +4013,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -4120,7 +4163,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -4305,7 +4349,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -4506,7 +4551,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -4547,7 +4593,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -4624,7 +4671,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -4825,7 +4873,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -4902,7 +4951,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -4995,7 +5045,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5196,7 +5247,8 @@ "kind": "typeParameterName" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5261,7 +5313,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5330,7 +5383,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5371,7 +5425,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5544,7 +5599,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5597,7 +5653,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5650,7 +5707,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5815,7 +5873,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5868,7 +5927,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5921,7 +5981,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -5986,7 +6047,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -6175,7 +6237,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -6228,7 +6291,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -6281,7 +6345,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInTypeAlias.baseline b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInTypeAlias.baseline index e6f1d4512889b..0f24ff6c767e6 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInTypeAlias.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsTypeParameterInTypeAlias.baseline @@ -61,7 +61,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -134,7 +135,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -207,7 +209,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -288,7 +291,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -377,7 +381,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -466,7 +471,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsVar.baseline b/tests/baselines/reference/quickInfoDisplayPartsVar.baseline index b56e1b315425a..250f10ff5334c 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsVar.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsVar.baseline @@ -37,7 +37,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -86,7 +87,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -127,7 +129,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -168,7 +171,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -217,7 +221,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -278,7 +283,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -339,7 +345,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -400,7 +407,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -461,7 +469,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -606,7 +615,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -751,7 +761,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -896,7 +907,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1001,7 +1013,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1106,7 +1119,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsVar.shims-pp.baseline b/tests/baselines/reference/quickInfoDisplayPartsVar.shims-pp.baseline index dfe65565790aa..5d072155c95b9 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsVar.shims-pp.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsVar.shims-pp.baseline @@ -37,7 +37,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -86,7 +87,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -127,7 +129,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -168,7 +171,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -217,7 +221,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -278,7 +283,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -339,7 +345,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -400,7 +407,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -461,7 +469,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -606,7 +615,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -751,7 +761,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -896,7 +907,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1001,7 +1013,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1106,7 +1119,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsVar.shims.baseline b/tests/baselines/reference/quickInfoDisplayPartsVar.shims.baseline index 249772f416ece..448595e3f64c5 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsVar.shims.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsVar.shims.baseline @@ -37,7 +37,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -86,7 +87,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -127,7 +129,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -168,7 +171,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -217,7 +221,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -278,7 +283,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -339,7 +345,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -400,7 +407,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -461,7 +469,8 @@ "kind": "keyword" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -606,7 +615,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -751,7 +761,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -896,7 +907,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1001,7 +1013,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -1106,7 +1119,8 @@ "kind": "punctuation" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/quickInfoDisplayPartsVarWithStringTypes01.baseline b/tests/baselines/reference/quickInfoDisplayPartsVarWithStringTypes01.baseline index 3c46a6ba6bd8b..92a09a4d7fa15 100644 --- a/tests/baselines/reference/quickInfoDisplayPartsVarWithStringTypes01.baseline +++ b/tests/baselines/reference/quickInfoDisplayPartsVarWithStringTypes01.baseline @@ -37,7 +37,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -78,7 +79,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } }, { @@ -135,7 +137,8 @@ "kind": "stringLiteral" } ], - "documentation": [] + "documentation": [], + "tags": [] } } ] \ No newline at end of file diff --git a/tests/baselines/reference/reExportDefaultExport.js b/tests/baselines/reference/reExportDefaultExport.js index cd306e411d500..ef9386da32a63 100644 --- a/tests/baselines/reference/reExportDefaultExport.js +++ b/tests/baselines/reference/reExportDefaultExport.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/es6/modules/reExportDefaultExport.ts] //// //// [m1.ts] - export default function f() { } export {f}; diff --git a/tests/baselines/reference/reExportDefaultExport.symbols b/tests/baselines/reference/reExportDefaultExport.symbols index cd0d6e493c946..a4ebfdc0ac5ab 100644 --- a/tests/baselines/reference/reExportDefaultExport.symbols +++ b/tests/baselines/reference/reExportDefaultExport.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f() { >f : Symbol(f, Decl(m1.ts, 0, 0)) } export {f}; ->f : Symbol(f, Decl(m1.ts, 3, 8)) +>f : Symbol(f, Decl(m1.ts, 2, 8)) === tests/cases/conformance/es6/modules/m2.ts === diff --git a/tests/baselines/reference/reExportDefaultExport.types b/tests/baselines/reference/reExportDefaultExport.types index f775571ac2c8d..09fce8c736533 100644 --- a/tests/baselines/reference/reExportDefaultExport.types +++ b/tests/baselines/reference/reExportDefaultExport.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/modules/m1.ts === - export default function f() { >f : () => void } diff --git a/tests/baselines/reference/reExportGlobalDeclaration1.errors.txt b/tests/baselines/reference/reExportGlobalDeclaration1.errors.txt index 0d83d8b94ee12..13d3ca9cfe6ca 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration1.errors.txt +++ b/tests/baselines/reference/reExportGlobalDeclaration1.errors.txt @@ -13,7 +13,6 @@ tests/cases/compiler/file2.ts(11,9): error TS2661: Cannot export 'b'. Only local ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare var x: number; declare var x1: number; declare let {a, b}: {a: number, b: number}; diff --git a/tests/baselines/reference/reExportGlobalDeclaration1.js b/tests/baselines/reference/reExportGlobalDeclaration1.js index 9ab432fd084db..334d20de2144a 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration1.js +++ b/tests/baselines/reference/reExportGlobalDeclaration1.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportGlobalDeclaration1.ts] //// //// [file1.d.ts] - declare var x: number; declare var x1: number; declare let {a, b}: {a: number, b: number}; diff --git a/tests/baselines/reference/reExportGlobalDeclaration2.errors.txt b/tests/baselines/reference/reExportGlobalDeclaration2.errors.txt index b24a52aff49f7..608c77fed1065 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration2.errors.txt +++ b/tests/baselines/reference/reExportGlobalDeclaration2.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/file2.ts(4,9): error TS2661: Cannot export 'I2'. Only local ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare interface I1 { x: number } diff --git a/tests/baselines/reference/reExportGlobalDeclaration2.js b/tests/baselines/reference/reExportGlobalDeclaration2.js index 52e55bb18c4fd..5e58bf4b68ab7 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration2.js +++ b/tests/baselines/reference/reExportGlobalDeclaration2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportGlobalDeclaration2.ts] //// //// [file1.d.ts] - declare interface I1 { x: number } diff --git a/tests/baselines/reference/reExportGlobalDeclaration3.errors.txt b/tests/baselines/reference/reExportGlobalDeclaration3.errors.txt index 2f469e8049198..436c4f0be919f 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration3.errors.txt +++ b/tests/baselines/reference/reExportGlobalDeclaration3.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/file2.ts(4,9): error TS2661: Cannot export 'NS2'. Only loca ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare namespace NS1 { export var foo: number; } diff --git a/tests/baselines/reference/reExportGlobalDeclaration3.js b/tests/baselines/reference/reExportGlobalDeclaration3.js index ed111b42197b9..0cd5132049d43 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration3.js +++ b/tests/baselines/reference/reExportGlobalDeclaration3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportGlobalDeclaration3.ts] //// //// [file1.d.ts] - declare namespace NS1 { export var foo: number; } diff --git a/tests/baselines/reference/reExportGlobalDeclaration4.errors.txt b/tests/baselines/reference/reExportGlobalDeclaration4.errors.txt index a3b58a276aebe..d4d6031d78be6 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration4.errors.txt +++ b/tests/baselines/reference/reExportGlobalDeclaration4.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/file2.ts(4,9): error TS2661: Cannot export 'Cls2'. Only loc ==== tests/cases/compiler/file1.d.ts (0 errors) ==== - declare class Cls1 { x: number } diff --git a/tests/baselines/reference/reExportGlobalDeclaration4.js b/tests/baselines/reference/reExportGlobalDeclaration4.js index a7a0e7525caa4..d860d20b83c1e 100644 --- a/tests/baselines/reference/reExportGlobalDeclaration4.js +++ b/tests/baselines/reference/reExportGlobalDeclaration4.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportGlobalDeclaration4.ts] //// //// [file1.d.ts] - declare class Cls1 { x: number } diff --git a/tests/baselines/reference/reExportUndefined1.errors.txt b/tests/baselines/reference/reExportUndefined1.errors.txt index 5042b4c4c0c2c..f0284383aca3d 100644 --- a/tests/baselines/reference/reExportUndefined1.errors.txt +++ b/tests/baselines/reference/reExportUndefined1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.ts(2,10): error TS2661: Cannot export 'undefined'. Only local declarations can be exported from a module. +tests/cases/compiler/a.ts(1,10): error TS2661: Cannot export 'undefined'. Only local declarations can be exported from a module. ==== tests/cases/compiler/a.ts (1 errors) ==== - export { undefined }; ~~~~~~~~~ !!! error TS2661: Cannot export 'undefined'. Only local declarations can be exported from a module. \ No newline at end of file diff --git a/tests/baselines/reference/reExportUndefined1.js b/tests/baselines/reference/reExportUndefined1.js index 7540901fa3027..3dfacd62df258 100644 --- a/tests/baselines/reference/reExportUndefined1.js +++ b/tests/baselines/reference/reExportUndefined1.js @@ -1,5 +1,4 @@ //// [a.ts] - export { undefined }; //// [a.js] diff --git a/tests/baselines/reference/reExportUndefined2.js b/tests/baselines/reference/reExportUndefined2.js index bde88442b33b7..49aacf98e6af8 100644 --- a/tests/baselines/reference/reExportUndefined2.js +++ b/tests/baselines/reference/reExportUndefined2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reExportUndefined2.ts] //// //// [a.ts] - var undefined; export { undefined }; diff --git a/tests/baselines/reference/reExportUndefined2.symbols b/tests/baselines/reference/reExportUndefined2.symbols index c4f532ed6dc9b..dbef6e66ee047 100644 --- a/tests/baselines/reference/reExportUndefined2.symbols +++ b/tests/baselines/reference/reExportUndefined2.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/a.ts === - var undefined; ->undefined : Symbol(undefined, Decl(a.ts, 1, 3)) +>undefined : Symbol(undefined, Decl(a.ts, 0, 3)) export { undefined }; ->undefined : Symbol(undefined, Decl(a.ts, 2, 8)) +>undefined : Symbol(undefined, Decl(a.ts, 1, 8)) === tests/cases/compiler/b.ts === import { undefined } from "./a"; diff --git a/tests/baselines/reference/reExportUndefined2.types b/tests/baselines/reference/reExportUndefined2.types index d3f3dc9d7263a..e6d5db146ebda 100644 --- a/tests/baselines/reference/reExportUndefined2.types +++ b/tests/baselines/reference/reExportUndefined2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - var undefined; >undefined : any diff --git a/tests/baselines/reference/reachabilityChecks1.errors.txt b/tests/baselines/reference/reachabilityChecks1.errors.txt index 18a453969a17f..0f1a9b7bb1eeb 100644 --- a/tests/baselines/reference/reachabilityChecks1.errors.txt +++ b/tests/baselines/reference/reachabilityChecks1.errors.txt @@ -1,14 +1,13 @@ -tests/cases/compiler/reachabilityChecks1.ts(3,1): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(7,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(19,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(31,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(48,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(61,5): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks1.ts(70,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(2,1): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(6,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(18,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(30,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(47,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(60,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(69,5): error TS7027: Unreachable code detected. ==== tests/cases/compiler/reachabilityChecks1.ts (7 errors) ==== - while (true); var x = 1; ~~~ diff --git a/tests/baselines/reference/reachabilityChecks1.js b/tests/baselines/reference/reachabilityChecks1.js index 97b914fc104e0..61bb2b42996fc 100644 --- a/tests/baselines/reference/reachabilityChecks1.js +++ b/tests/baselines/reference/reachabilityChecks1.js @@ -1,5 +1,4 @@ //// [reachabilityChecks1.ts] - while (true); var x = 1; diff --git a/tests/baselines/reference/reachabilityChecks2.errors.txt b/tests/baselines/reference/reachabilityChecks2.errors.txt index cd48f84f8e151..9061effeb667f 100644 --- a/tests/baselines/reference/reachabilityChecks2.errors.txt +++ b/tests/baselines/reference/reachabilityChecks2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/reachabilityChecks2.ts(5,1): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks2.ts(4,1): error TS7027: Unreachable code detected. ==== tests/cases/compiler/reachabilityChecks2.ts (1 errors) ==== - while (true) { } const enum E { X } diff --git a/tests/baselines/reference/reachabilityChecks2.js b/tests/baselines/reference/reachabilityChecks2.js index a17b51b4ca61e..f5f8245bbe649 100644 --- a/tests/baselines/reference/reachabilityChecks2.js +++ b/tests/baselines/reference/reachabilityChecks2.js @@ -1,5 +1,4 @@ //// [reachabilityChecks2.ts] - while (true) { } const enum E { X } diff --git a/tests/baselines/reference/reachabilityChecks3.errors.txt b/tests/baselines/reference/reachabilityChecks3.errors.txt index 1114f245f44c6..7e95a24c65ea4 100644 --- a/tests/baselines/reference/reachabilityChecks3.errors.txt +++ b/tests/baselines/reference/reachabilityChecks3.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/reachabilityChecks3.ts(3,1): error TS7028: Unused label. -tests/cases/compiler/reachabilityChecks3.ts(12,5): error TS7028: Unused label. -tests/cases/compiler/reachabilityChecks3.ts(15,17): error TS7028: Unused label. +tests/cases/compiler/reachabilityChecks3.ts(2,1): error TS7028: Unused label. +tests/cases/compiler/reachabilityChecks3.ts(11,5): error TS7028: Unused label. +tests/cases/compiler/reachabilityChecks3.ts(14,17): error TS7028: Unused label. ==== tests/cases/compiler/reachabilityChecks3.ts (3 errors) ==== - let x = 1; loop: while (true) { ~~~~ diff --git a/tests/baselines/reference/reachabilityChecks3.js b/tests/baselines/reference/reachabilityChecks3.js index dd22453938d12..5672e7ac1ed27 100644 --- a/tests/baselines/reference/reachabilityChecks3.js +++ b/tests/baselines/reference/reachabilityChecks3.js @@ -1,5 +1,4 @@ //// [reachabilityChecks3.ts] - let x = 1; loop: while (true) { if (x == 100) { diff --git a/tests/baselines/reference/reachabilityChecks4.errors.txt b/tests/baselines/reference/reachabilityChecks4.errors.txt index ba9519462e7e8..fdbb9d23ee800 100644 --- a/tests/baselines/reference/reachabilityChecks4.errors.txt +++ b/tests/baselines/reference/reachabilityChecks4.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/reachabilityChecks4.ts(7,9): error TS7029: Fallthrough case in switch. +tests/cases/compiler/reachabilityChecks4.ts(6,9): error TS7029: Fallthrough case in switch. ==== tests/cases/compiler/reachabilityChecks4.ts (1 errors) ==== - function foo(x, y) { switch (x) { case 1: diff --git a/tests/baselines/reference/reachabilityChecks4.js b/tests/baselines/reference/reachabilityChecks4.js index 588644c5a05ea..de84c445cff75 100644 --- a/tests/baselines/reference/reachabilityChecks4.js +++ b/tests/baselines/reference/reachabilityChecks4.js @@ -1,5 +1,4 @@ //// [reachabilityChecks4.ts] - function foo(x, y) { switch (x) { case 1: diff --git a/tests/baselines/reference/reachabilityChecks5.errors.txt b/tests/baselines/reference/reachabilityChecks5.errors.txt index 4a894261a3d59..4dc7c1705f1c8 100644 --- a/tests/baselines/reference/reachabilityChecks5.errors.txt +++ b/tests/baselines/reference/reachabilityChecks5.errors.txt @@ -1,18 +1,17 @@ -tests/cases/compiler/reachabilityChecks5.ts(6,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(19,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. -tests/cases/compiler/reachabilityChecks5.ts(31,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(41,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(52,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(80,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(86,13): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks5.ts(94,17): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(97,13): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks5.ts(116,18): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks5.ts(123,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks5.ts(5,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(18,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/reachabilityChecks5.ts(30,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(40,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(51,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(79,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(85,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks5.ts(93,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(96,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks5.ts(115,18): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(122,13): error TS7027: Unreachable code detected. ==== tests/cases/compiler/reachabilityChecks5.ts (11 errors) ==== - function f0(x): number { while (true); } diff --git a/tests/baselines/reference/reachabilityChecks5.js b/tests/baselines/reference/reachabilityChecks5.js index a6c507ac87b88..947b11b48c535 100644 --- a/tests/baselines/reference/reachabilityChecks5.js +++ b/tests/baselines/reference/reachabilityChecks5.js @@ -1,5 +1,4 @@ //// [reachabilityChecks5.ts] - function f0(x): number { while (true); } diff --git a/tests/baselines/reference/reachabilityChecks6.errors.txt b/tests/baselines/reference/reachabilityChecks6.errors.txt index 24832d9ab3892..9dadf3b2d6f51 100644 --- a/tests/baselines/reference/reachabilityChecks6.errors.txt +++ b/tests/baselines/reference/reachabilityChecks6.errors.txt @@ -1,17 +1,16 @@ -tests/cases/compiler/reachabilityChecks6.ts(6,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(31,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(41,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(52,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(80,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(86,13): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks6.ts(94,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(97,13): error TS7027: Unreachable code detected. -tests/cases/compiler/reachabilityChecks6.ts(116,10): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks6.ts(123,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks6.ts(5,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(30,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(40,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(51,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(79,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(85,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks6.ts(93,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(96,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks6.ts(115,10): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks6.ts(122,13): error TS7027: Unreachable code detected. ==== tests/cases/compiler/reachabilityChecks6.ts (10 errors) ==== - function f0(x) { while (true); } diff --git a/tests/baselines/reference/reachabilityChecks6.js b/tests/baselines/reference/reachabilityChecks6.js index 9be23d32048ec..169d3f7486671 100644 --- a/tests/baselines/reference/reachabilityChecks6.js +++ b/tests/baselines/reference/reachabilityChecks6.js @@ -1,5 +1,4 @@ //// [reachabilityChecks6.ts] - function f0(x) { while (true); } diff --git a/tests/baselines/reference/reachabilityChecks7.errors.txt b/tests/baselines/reference/reachabilityChecks7.errors.txt index 1596c7d9a3bc3..9ac2d0c1ad8ae 100644 --- a/tests/baselines/reference/reachabilityChecks7.errors.txt +++ b/tests/baselines/reference/reachabilityChecks7.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/reachabilityChecks7.ts(14,16): error TS7030: Not all code paths return a value. -tests/cases/compiler/reachabilityChecks7.ts(18,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/reachabilityChecks7.ts(13,16): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks7.ts(17,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ==== tests/cases/compiler/reachabilityChecks7.ts (2 errors) ==== - // async function without return type annotation - error async function f1() { } diff --git a/tests/baselines/reference/reachabilityChecks7.js b/tests/baselines/reference/reachabilityChecks7.js index c17472205a4c9..30addff4aecca 100644 --- a/tests/baselines/reference/reachabilityChecks7.js +++ b/tests/baselines/reference/reachabilityChecks7.js @@ -1,5 +1,4 @@ //// [reachabilityChecks7.ts] - // async function without return type annotation - error async function f1() { } diff --git a/tests/baselines/reference/reactImportDropped.js b/tests/baselines/reference/reactImportDropped.js index 7ada76b42f429..53ff422fa6e27 100644 --- a/tests/baselines/reference/reactImportDropped.js +++ b/tests/baselines/reference/reactImportDropped.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reactImportDropped.ts] //// //// [react.d.ts] - export = React; export as namespace React; diff --git a/tests/baselines/reference/reactImportDropped.symbols b/tests/baselines/reference/reactImportDropped.symbols index 0daa49353fa29..71c25480c7241 100644 --- a/tests/baselines/reference/reactImportDropped.symbols +++ b/tests/baselines/reference/reactImportDropped.symbols @@ -1,45 +1,44 @@ === tests/cases/compiler/react.d.ts === - export = React; ->React : Symbol(React, Decl(react.d.ts, 2, 26)) +>React : Symbol(React, Decl(react.d.ts, 1, 26)) export as namespace React; ->React : Symbol(React, Decl(react.d.ts, 1, 15)) +>React : Symbol(React, Decl(react.d.ts, 0, 15)) declare namespace React { ->React : Symbol(React, Decl(react.d.ts, 2, 26)) +>React : Symbol(React, Decl(react.d.ts, 1, 26)) function createClass(spec: any): ClassicComponentClass; ->createClass : Symbol(createClass, Decl(react.d.ts, 4, 25)) ->spec : Symbol(spec, Decl(react.d.ts, 6, 25)) ->ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 6, 59)) +>createClass : Symbol(createClass, Decl(react.d.ts, 3, 25)) +>spec : Symbol(spec, Decl(react.d.ts, 5, 25)) +>ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 5, 59)) interface ClassicComponentClass { ->ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 6, 59)) +>ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 5, 59)) new (props?: any): ClassicComponentClass; ->props : Symbol(props, Decl(react.d.ts, 9, 13)) ->ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 6, 59)) +>props : Symbol(props, Decl(react.d.ts, 8, 13)) +>ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 5, 59)) } } declare global { ->global : Symbol(global, Decl(react.d.ts, 11, 1)) +>global : Symbol(global, Decl(react.d.ts, 10, 1)) namespace JSX { ->JSX : Symbol(JSX, Decl(react.d.ts, 13, 16)) +>JSX : Symbol(JSX, Decl(react.d.ts, 12, 16)) interface ElementAttributesProperty { } ->ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(react.d.ts, 14, 19)) +>ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(react.d.ts, 13, 19)) } } === tests/cases/compiler/src/components/TabBar.js === export default React.createClass({ ->React.createClass : Symbol(React.createClass, Decl(react.d.ts, 4, 25)) ->React : Symbol(React, Decl(react.d.ts, 1, 15)) ->createClass : Symbol(React.createClass, Decl(react.d.ts, 4, 25)) +>React.createClass : Symbol(React.createClass, Decl(react.d.ts, 3, 25)) +>React : Symbol(React, Decl(react.d.ts, 0, 15)) +>createClass : Symbol(React.createClass, Decl(react.d.ts, 3, 25)) render() { >render : Symbol(render, Decl(TabBar.js, 0, 34)) diff --git a/tests/baselines/reference/reactImportDropped.types b/tests/baselines/reference/reactImportDropped.types index 36f1a6a47793a..ae8b1308c037b 100644 --- a/tests/baselines/reference/reactImportDropped.types +++ b/tests/baselines/reference/reactImportDropped.types @@ -1,5 +1,4 @@ === tests/cases/compiler/react.d.ts === - export = React; >React : typeof React diff --git a/tests/baselines/reference/reactNamespaceImportPresevation.js b/tests/baselines/reference/reactNamespaceImportPresevation.js index 682dd0f7882d8..a3e9ac800fee4 100644 --- a/tests/baselines/reference/reactNamespaceImportPresevation.js +++ b/tests/baselines/reference/reactNamespaceImportPresevation.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/reactNamespaceImportPresevation.tsx] //// //// [modules.d.ts] - declare module "my-React-Lib" { var a: any; export = a; diff --git a/tests/baselines/reference/reactNamespaceImportPresevation.symbols b/tests/baselines/reference/reactNamespaceImportPresevation.symbols index caeca7cefcb99..dadd6f3e7a75c 100644 --- a/tests/baselines/reference/reactNamespaceImportPresevation.symbols +++ b/tests/baselines/reference/reactNamespaceImportPresevation.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modules.d.ts === - declare module "my-React-Lib" { var a: any; ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) export = a; ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) } === tests/cases/compiler/test.tsx === diff --git a/tests/baselines/reference/reactNamespaceImportPresevation.types b/tests/baselines/reference/reactNamespaceImportPresevation.types index 931a86d248de0..9f45b5cb46257 100644 --- a/tests/baselines/reference/reactNamespaceImportPresevation.types +++ b/tests/baselines/reference/reactNamespaceImportPresevation.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modules.d.ts === - declare module "my-React-Lib" { var a: any; >a : any diff --git a/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt b/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt index 2e72775fe9c23..721279e561d04 100644 --- a/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt +++ b/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt @@ -1,10 +1,9 @@ error TS5059: Invalid value for '--reactNamespace'. 'my-React-Lib' is not a valid identifier. -tests/cases/compiler/reactNamespaceInvalidInput.tsx(2,2): error TS2304: Cannot find name 'my-React-Lib'. +tests/cases/compiler/reactNamespaceInvalidInput.tsx(1,2): error TS2304: Cannot find name 'my-React-Lib'. !!! error TS5059: Invalid value for '--reactNamespace'. 'my-React-Lib' is not a valid identifier. ==== tests/cases/compiler/reactNamespaceInvalidInput.tsx (1 errors) ==== - ; ~~~ !!! error TS2304: Cannot find name 'my-React-Lib'. diff --git a/tests/baselines/reference/reactNamespaceInvalidInput.js b/tests/baselines/reference/reactNamespaceInvalidInput.js index 69918fe976fc0..44502ccf1677b 100644 --- a/tests/baselines/reference/reactNamespaceInvalidInput.js +++ b/tests/baselines/reference/reactNamespaceInvalidInput.js @@ -1,5 +1,4 @@ //// [reactNamespaceInvalidInput.tsx] - ; diff --git a/tests/baselines/reference/reactNamespaceJSXEmit.js b/tests/baselines/reference/reactNamespaceJSXEmit.js index 3a21504bb80e7..fc30f7f7bfaa6 100644 --- a/tests/baselines/reference/reactNamespaceJSXEmit.js +++ b/tests/baselines/reference/reactNamespaceJSXEmit.js @@ -1,5 +1,4 @@ //// [reactNamespaceJSXEmit.tsx] - declare var myReactLib: any; declare var foo: any; declare var Bar: any; diff --git a/tests/baselines/reference/reactNamespaceJSXEmit.symbols b/tests/baselines/reference/reactNamespaceJSXEmit.symbols index 55aae09776cf7..b8e58fb1702ca 100644 --- a/tests/baselines/reference/reactNamespaceJSXEmit.symbols +++ b/tests/baselines/reference/reactNamespaceJSXEmit.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/reactNamespaceJSXEmit.tsx === - declare var myReactLib: any; ->myReactLib : Symbol(myReactLib, Decl(reactNamespaceJSXEmit.tsx, 1, 11)) +>myReactLib : Symbol(myReactLib, Decl(reactNamespaceJSXEmit.tsx, 0, 11)) declare var foo: any; ->foo : Symbol(foo, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) +>foo : Symbol(foo, Decl(reactNamespaceJSXEmit.tsx, 1, 11)) declare var Bar: any; ->Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) +>Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) declare var x: any; ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 4, 11)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ; >foo : Symbol(unknown) ->data : Symbol(data, Decl(reactNamespaceJSXEmit.tsx, 6, 4)) +>data : Symbol(data, Decl(reactNamespaceJSXEmit.tsx, 5, 4)) ; ->Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 7, 4)) ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 4, 11)) +>Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 6, 4)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ; >x-component : Symbol(unknown) ; ->Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 4, 11)) +>Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ; ->Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) ->x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 4, 11)) ->y : Symbol(y, Decl(reactNamespaceJSXEmit.tsx, 10, 13)) +>Bar : Symbol(Bar, Decl(reactNamespaceJSXEmit.tsx, 2, 11)) +>x : Symbol(x, Decl(reactNamespaceJSXEmit.tsx, 3, 11)) +>y : Symbol(y, Decl(reactNamespaceJSXEmit.tsx, 9, 13)) diff --git a/tests/baselines/reference/reactNamespaceJSXEmit.types b/tests/baselines/reference/reactNamespaceJSXEmit.types index 0f6fbd6830942..0c1200b362bd9 100644 --- a/tests/baselines/reference/reactNamespaceJSXEmit.types +++ b/tests/baselines/reference/reactNamespaceJSXEmit.types @@ -1,5 +1,4 @@ === tests/cases/compiler/reactNamespaceJSXEmit.tsx === - declare var myReactLib: any; >myReactLib : any diff --git a/tests/baselines/reference/reactNamespaceMissingDeclaration.errors.txt b/tests/baselines/reference/reactNamespaceMissingDeclaration.errors.txt index f87d223f82458..2b5194cc8abc1 100644 --- a/tests/baselines/reference/reactNamespaceMissingDeclaration.errors.txt +++ b/tests/baselines/reference/reactNamespaceMissingDeclaration.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/reactNamespaceMissingDeclaration.tsx(3,2): error TS2304: Cannot find name 'myReactLib'. +tests/cases/compiler/reactNamespaceMissingDeclaration.tsx(2,2): error TS2304: Cannot find name 'myReactLib'. ==== tests/cases/compiler/reactNamespaceMissingDeclaration.tsx (1 errors) ==== - // Error myReactLib not declared ~~~ diff --git a/tests/baselines/reference/reactNamespaceMissingDeclaration.js b/tests/baselines/reference/reactNamespaceMissingDeclaration.js index 8faeffa64964d..784174ac7281b 100644 --- a/tests/baselines/reference/reactNamespaceMissingDeclaration.js +++ b/tests/baselines/reference/reactNamespaceMissingDeclaration.js @@ -1,5 +1,4 @@ //// [reactNamespaceMissingDeclaration.tsx] - // Error myReactLib not declared diff --git a/tests/baselines/reference/readonlyInDeclarationFile.js b/tests/baselines/reference/readonlyInDeclarationFile.js index 71e48272ecc0c..598c433d81fcb 100644 --- a/tests/baselines/reference/readonlyInDeclarationFile.js +++ b/tests/baselines/reference/readonlyInDeclarationFile.js @@ -1,5 +1,4 @@ //// [readonlyInDeclarationFile.ts] - interface Foo { readonly x: number; readonly [x: string]: Object; diff --git a/tests/baselines/reference/readonlyInDeclarationFile.symbols b/tests/baselines/reference/readonlyInDeclarationFile.symbols index c5f3b066a5dc6..9ec0e7f5e78e3 100644 --- a/tests/baselines/reference/readonlyInDeclarationFile.symbols +++ b/tests/baselines/reference/readonlyInDeclarationFile.symbols @@ -1,142 +1,141 @@ === tests/cases/compiler/readonlyInDeclarationFile.ts === - interface Foo { >Foo : Symbol(Foo, Decl(readonlyInDeclarationFile.ts, 0, 0)) readonly x: number; ->x : Symbol(Foo.x, Decl(readonlyInDeclarationFile.ts, 1, 15)) +>x : Symbol(Foo.x, Decl(readonlyInDeclarationFile.ts, 0, 15)) readonly [x: string]: Object; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 3, 14)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 2, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } class C { ->C : Symbol(C, Decl(readonlyInDeclarationFile.ts, 4, 1)) +>C : Symbol(C, Decl(readonlyInDeclarationFile.ts, 3, 1)) readonly [x: string]: Object; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 7, 14)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 6, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) private readonly a1: number; ->a1 : Symbol(C.a1, Decl(readonlyInDeclarationFile.ts, 7, 33)) +>a1 : Symbol(C.a1, Decl(readonlyInDeclarationFile.ts, 6, 33)) protected readonly a2: number; ->a2 : Symbol(C.a2, Decl(readonlyInDeclarationFile.ts, 8, 32)) +>a2 : Symbol(C.a2, Decl(readonlyInDeclarationFile.ts, 7, 32)) public readonly a3: number; ->a3 : Symbol(C.a3, Decl(readonlyInDeclarationFile.ts, 9, 34)) +>a3 : Symbol(C.a3, Decl(readonlyInDeclarationFile.ts, 8, 34)) private get b1() { return 1 } ->b1 : Symbol(C.b1, Decl(readonlyInDeclarationFile.ts, 10, 31)) +>b1 : Symbol(C.b1, Decl(readonlyInDeclarationFile.ts, 9, 31)) protected get b2() { return 1 } ->b2 : Symbol(C.b2, Decl(readonlyInDeclarationFile.ts, 11, 33)) +>b2 : Symbol(C.b2, Decl(readonlyInDeclarationFile.ts, 10, 33)) public get b3() { return 1 } ->b3 : Symbol(C.b3, Decl(readonlyInDeclarationFile.ts, 12, 35)) +>b3 : Symbol(C.b3, Decl(readonlyInDeclarationFile.ts, 11, 35)) private get c1() { return 1 } ->c1 : Symbol(C.c1, Decl(readonlyInDeclarationFile.ts, 13, 32), Decl(readonlyInDeclarationFile.ts, 14, 33)) +>c1 : Symbol(C.c1, Decl(readonlyInDeclarationFile.ts, 12, 32), Decl(readonlyInDeclarationFile.ts, 13, 33)) private set c1(value) { } ->c1 : Symbol(C.c1, Decl(readonlyInDeclarationFile.ts, 13, 32), Decl(readonlyInDeclarationFile.ts, 14, 33)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 15, 19)) +>c1 : Symbol(C.c1, Decl(readonlyInDeclarationFile.ts, 12, 32), Decl(readonlyInDeclarationFile.ts, 13, 33)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 14, 19)) protected get c2() { return 1 } ->c2 : Symbol(C.c2, Decl(readonlyInDeclarationFile.ts, 15, 29), Decl(readonlyInDeclarationFile.ts, 16, 35)) +>c2 : Symbol(C.c2, Decl(readonlyInDeclarationFile.ts, 14, 29), Decl(readonlyInDeclarationFile.ts, 15, 35)) protected set c2(value) { } ->c2 : Symbol(C.c2, Decl(readonlyInDeclarationFile.ts, 15, 29), Decl(readonlyInDeclarationFile.ts, 16, 35)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 17, 21)) +>c2 : Symbol(C.c2, Decl(readonlyInDeclarationFile.ts, 14, 29), Decl(readonlyInDeclarationFile.ts, 15, 35)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 16, 21)) public get c3() { return 1 } ->c3 : Symbol(C.c3, Decl(readonlyInDeclarationFile.ts, 17, 31), Decl(readonlyInDeclarationFile.ts, 18, 32)) +>c3 : Symbol(C.c3, Decl(readonlyInDeclarationFile.ts, 16, 31), Decl(readonlyInDeclarationFile.ts, 17, 32)) public set c3(value) { } ->c3 : Symbol(C.c3, Decl(readonlyInDeclarationFile.ts, 17, 31), Decl(readonlyInDeclarationFile.ts, 18, 32)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 19, 18)) +>c3 : Symbol(C.c3, Decl(readonlyInDeclarationFile.ts, 16, 31), Decl(readonlyInDeclarationFile.ts, 17, 32)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 18, 18)) private static readonly s1: number; ->s1 : Symbol(C.s1, Decl(readonlyInDeclarationFile.ts, 19, 28)) +>s1 : Symbol(C.s1, Decl(readonlyInDeclarationFile.ts, 18, 28)) protected static readonly s2: number; ->s2 : Symbol(C.s2, Decl(readonlyInDeclarationFile.ts, 20, 39)) +>s2 : Symbol(C.s2, Decl(readonlyInDeclarationFile.ts, 19, 39)) public static readonly s3: number; ->s3 : Symbol(C.s3, Decl(readonlyInDeclarationFile.ts, 21, 41)) +>s3 : Symbol(C.s3, Decl(readonlyInDeclarationFile.ts, 20, 41)) private static get t1() { return 1 } ->t1 : Symbol(C.t1, Decl(readonlyInDeclarationFile.ts, 22, 38)) +>t1 : Symbol(C.t1, Decl(readonlyInDeclarationFile.ts, 21, 38)) protected static get t2() { return 1 } ->t2 : Symbol(C.t2, Decl(readonlyInDeclarationFile.ts, 23, 40)) +>t2 : Symbol(C.t2, Decl(readonlyInDeclarationFile.ts, 22, 40)) public static get t3() { return 1 } ->t3 : Symbol(C.t3, Decl(readonlyInDeclarationFile.ts, 24, 42)) +>t3 : Symbol(C.t3, Decl(readonlyInDeclarationFile.ts, 23, 42)) private static get u1() { return 1 } ->u1 : Symbol(C.u1, Decl(readonlyInDeclarationFile.ts, 25, 39), Decl(readonlyInDeclarationFile.ts, 26, 40)) +>u1 : Symbol(C.u1, Decl(readonlyInDeclarationFile.ts, 24, 39), Decl(readonlyInDeclarationFile.ts, 25, 40)) private static set u1(value) { } ->u1 : Symbol(C.u1, Decl(readonlyInDeclarationFile.ts, 25, 39), Decl(readonlyInDeclarationFile.ts, 26, 40)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 27, 26)) +>u1 : Symbol(C.u1, Decl(readonlyInDeclarationFile.ts, 24, 39), Decl(readonlyInDeclarationFile.ts, 25, 40)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 26, 26)) protected static get u2() { return 1 } ->u2 : Symbol(C.u2, Decl(readonlyInDeclarationFile.ts, 27, 36), Decl(readonlyInDeclarationFile.ts, 28, 42)) +>u2 : Symbol(C.u2, Decl(readonlyInDeclarationFile.ts, 26, 36), Decl(readonlyInDeclarationFile.ts, 27, 42)) protected static set u2(value) { } ->u2 : Symbol(C.u2, Decl(readonlyInDeclarationFile.ts, 27, 36), Decl(readonlyInDeclarationFile.ts, 28, 42)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 29, 28)) +>u2 : Symbol(C.u2, Decl(readonlyInDeclarationFile.ts, 26, 36), Decl(readonlyInDeclarationFile.ts, 27, 42)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 28, 28)) public static get u3() { return 1 } ->u3 : Symbol(C.u3, Decl(readonlyInDeclarationFile.ts, 29, 38), Decl(readonlyInDeclarationFile.ts, 30, 39)) +>u3 : Symbol(C.u3, Decl(readonlyInDeclarationFile.ts, 28, 38), Decl(readonlyInDeclarationFile.ts, 29, 39)) public static set u3(value) { } ->u3 : Symbol(C.u3, Decl(readonlyInDeclarationFile.ts, 29, 38), Decl(readonlyInDeclarationFile.ts, 30, 39)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 31, 25)) +>u3 : Symbol(C.u3, Decl(readonlyInDeclarationFile.ts, 28, 38), Decl(readonlyInDeclarationFile.ts, 29, 39)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 30, 25)) } var z: { ->z : Symbol(z, Decl(readonlyInDeclarationFile.ts, 34, 3)) +>z : Symbol(z, Decl(readonlyInDeclarationFile.ts, 33, 3)) readonly a: string; ->a : Symbol(a, Decl(readonlyInDeclarationFile.ts, 34, 8)) +>a : Symbol(a, Decl(readonlyInDeclarationFile.ts, 33, 8)) readonly [x: string]: Object; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 36, 14)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 35, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function f() { ->f : Symbol(f, Decl(readonlyInDeclarationFile.ts, 37, 1)) +>f : Symbol(f, Decl(readonlyInDeclarationFile.ts, 36, 1)) return { get x() { return 1; }, ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 40, 12)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 39, 12)) get y() { return 1; }, ->y : Symbol(y, Decl(readonlyInDeclarationFile.ts, 41, 30), Decl(readonlyInDeclarationFile.ts, 42, 30)) +>y : Symbol(y, Decl(readonlyInDeclarationFile.ts, 40, 30), Decl(readonlyInDeclarationFile.ts, 41, 30)) set y(value) { } ->y : Symbol(y, Decl(readonlyInDeclarationFile.ts, 41, 30), Decl(readonlyInDeclarationFile.ts, 42, 30)) ->value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 43, 14)) +>y : Symbol(y, Decl(readonlyInDeclarationFile.ts, 40, 30), Decl(readonlyInDeclarationFile.ts, 41, 30)) +>value : Symbol(value, Decl(readonlyInDeclarationFile.ts, 42, 14)) } } function g() { ->g : Symbol(g, Decl(readonlyInDeclarationFile.ts, 45, 1)) +>g : Symbol(g, Decl(readonlyInDeclarationFile.ts, 44, 1)) var x: { ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 48, 7)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 47, 7)) readonly a: string; ->a : Symbol(a, Decl(readonlyInDeclarationFile.ts, 48, 12)) +>a : Symbol(a, Decl(readonlyInDeclarationFile.ts, 47, 12)) readonly [x: string]: Object; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 50, 18)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 49, 18)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } return x; ->x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 48, 7)) +>x : Symbol(x, Decl(readonlyInDeclarationFile.ts, 47, 7)) } diff --git a/tests/baselines/reference/readonlyInDeclarationFile.types b/tests/baselines/reference/readonlyInDeclarationFile.types index ca83a0a4c01f2..668188a9c422b 100644 --- a/tests/baselines/reference/readonlyInDeclarationFile.types +++ b/tests/baselines/reference/readonlyInDeclarationFile.types @@ -1,5 +1,4 @@ === tests/cases/compiler/readonlyInDeclarationFile.ts === - interface Foo { >Foo : Foo diff --git a/tests/baselines/reference/readonlyInNonPropertyParameters.errors.txt b/tests/baselines/reference/readonlyInNonPropertyParameters.errors.txt index 9e759cb83432d..3522a2e50fc9f 100644 --- a/tests/baselines/reference/readonlyInNonPropertyParameters.errors.txt +++ b/tests/baselines/reference/readonlyInNonPropertyParameters.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/readonlyInNonPropertyParameters.ts(4,9): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/readonlyInNonPropertyParameters.ts(5,8): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/readonlyInNonPropertyParameters.ts(7,2): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/readonlyInNonPropertyParameters.ts(3,9): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/readonlyInNonPropertyParameters.ts(4,8): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/readonlyInNonPropertyParameters.ts(6,2): error TS2369: A parameter property is only allowed in a constructor implementation. ==== tests/cases/compiler/readonlyInNonPropertyParameters.ts (3 errors) ==== - // `readonly` won't work outside of property parameters class X { method(readonly x: number) {} diff --git a/tests/baselines/reference/readonlyInNonPropertyParameters.js b/tests/baselines/reference/readonlyInNonPropertyParameters.js index db58f73d2ffef..658cf1331cdaf 100644 --- a/tests/baselines/reference/readonlyInNonPropertyParameters.js +++ b/tests/baselines/reference/readonlyInNonPropertyParameters.js @@ -1,5 +1,4 @@ //// [readonlyInNonPropertyParameters.ts] - // `readonly` won't work outside of property parameters class X { method(readonly x: number) {} diff --git a/tests/baselines/reference/readonlyMembers.errors.txt b/tests/baselines/reference/readonlyMembers.errors.txt index 7a6b74359d16e..9baf37f27e7f1 100644 --- a/tests/baselines/reference/readonlyMembers.errors.txt +++ b/tests/baselines/reference/readonlyMembers.errors.txt @@ -1,22 +1,21 @@ -tests/cases/compiler/readonlyMembers.ts(7,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(8,3): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(17,14): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(19,18): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(20,18): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(21,18): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(25,14): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(26,14): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(27,14): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(36,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(40,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(49,3): error TS2540: Cannot assign to 'A' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(56,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. -tests/cases/compiler/readonlyMembers.ts(62,1): error TS2542: Index signature in type '{ readonly [x: string]: string; }' only permits reading. -tests/cases/compiler/readonlyMembers.ts(65,1): error TS2542: Index signature in type '{ [x: string]: string; readonly [x: number]: string; }' only permits reading. +tests/cases/compiler/readonlyMembers.ts(6,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(7,3): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(16,14): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(18,18): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(19,18): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(20,18): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(24,14): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(25,14): error TS2540: Cannot assign to 'b' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(26,14): error TS2540: Cannot assign to 'c' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(35,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(39,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(48,3): error TS2540: Cannot assign to 'A' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(55,3): error TS2540: Cannot assign to 'a' because it is a constant or a read-only property. +tests/cases/compiler/readonlyMembers.ts(61,1): error TS2542: Index signature in type '{ readonly [x: string]: string; }' only permits reading. +tests/cases/compiler/readonlyMembers.ts(64,1): error TS2542: Index signature in type '{ [x: string]: string; readonly [x: number]: string; }' only permits reading. ==== tests/cases/compiler/readonlyMembers.ts (15 errors) ==== - interface X { readonly a: number; readonly b?: number; diff --git a/tests/baselines/reference/readonlyMembers.js b/tests/baselines/reference/readonlyMembers.js index 899c52d86262c..7ba4b992f7876 100644 --- a/tests/baselines/reference/readonlyMembers.js +++ b/tests/baselines/reference/readonlyMembers.js @@ -1,5 +1,4 @@ //// [readonlyMembers.ts] - interface X { readonly a: number; readonly b?: number; diff --git a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.js b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.js index b3ef0cba312f2..4922b59f5b319 100644 --- a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.js +++ b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.js @@ -1,5 +1,4 @@ //// [recurringTypeParamForContainerOfBase01.ts] - interface BoxOfFoo> { item: T } diff --git a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.symbols b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.symbols index 48ea1ffa0cf5c..2c55e217fc296 100644 --- a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.symbols +++ b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.symbols @@ -1,37 +1,36 @@ === tests/cases/conformance/types/typeParameters/recurringTypeParamForContainerOfBase01.ts === - interface BoxOfFoo> { >BoxOfFoo : Symbol(BoxOfFoo, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 0)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 1, 19)) ->Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 3, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 1, 19)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 19)) +>Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 2, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 19)) item: T ->item : Symbol(BoxOfFoo.item, Decl(recurringTypeParamForContainerOfBase01.ts, 1, 38)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 1, 19)) +>item : Symbol(BoxOfFoo.item, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 38)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 19)) } interface Foo> { ->Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 3, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 5, 14)) ->Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 3, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 5, 14)) +>Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 2, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 4, 14)) +>Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 2, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 4, 14)) self: T; ->self : Symbol(Foo.self, Decl(recurringTypeParamForContainerOfBase01.ts, 5, 33)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 5, 14)) +>self : Symbol(Foo.self, Decl(recurringTypeParamForContainerOfBase01.ts, 4, 33)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 4, 14)) } interface Bar> extends Foo { ->Bar : Symbol(Bar, Decl(recurringTypeParamForContainerOfBase01.ts, 7, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 14)) ->Bar : Symbol(Bar, Decl(recurringTypeParamForContainerOfBase01.ts, 7, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 14)) ->Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 3, 1)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 14)) +>Bar : Symbol(Bar, Decl(recurringTypeParamForContainerOfBase01.ts, 6, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 14)) +>Bar : Symbol(Bar, Decl(recurringTypeParamForContainerOfBase01.ts, 6, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 14)) +>Foo : Symbol(Foo, Decl(recurringTypeParamForContainerOfBase01.ts, 2, 1)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 14)) other: BoxOfFoo; ->other : Symbol(Bar.other, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 48)) +>other : Symbol(Bar.other, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 48)) >BoxOfFoo : Symbol(BoxOfFoo, Decl(recurringTypeParamForContainerOfBase01.ts, 0, 0)) ->T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 9, 14)) +>T : Symbol(T, Decl(recurringTypeParamForContainerOfBase01.ts, 8, 14)) } diff --git a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.types b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.types index 38b23263f01d4..432fccfc55280 100644 --- a/tests/baselines/reference/recurringTypeParamForContainerOfBase01.types +++ b/tests/baselines/reference/recurringTypeParamForContainerOfBase01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeParameters/recurringTypeParamForContainerOfBase01.ts === - interface BoxOfFoo> { >BoxOfFoo : BoxOfFoo >T : T diff --git a/tests/baselines/reference/recursiveIdenticalOverloadResolution.js b/tests/baselines/reference/recursiveIdenticalOverloadResolution.js index 3c53c2b2a0ac4..772b561e9a6fb 100644 --- a/tests/baselines/reference/recursiveIdenticalOverloadResolution.js +++ b/tests/baselines/reference/recursiveIdenticalOverloadResolution.js @@ -1,5 +1,4 @@ //// [recursiveIdenticalOverloadResolution.ts] - module M { interface I { (i: I): I; } diff --git a/tests/baselines/reference/recursiveIdenticalOverloadResolution.symbols b/tests/baselines/reference/recursiveIdenticalOverloadResolution.symbols index a759f07eda1d7..3b89b9ed7e7b7 100644 --- a/tests/baselines/reference/recursiveIdenticalOverloadResolution.symbols +++ b/tests/baselines/reference/recursiveIdenticalOverloadResolution.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/recursiveIdenticalOverloadResolution.ts === - module M { >M : Symbol(M, Decl(recursiveIdenticalOverloadResolution.ts, 0, 0)) interface I { (i: I): I; } ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 3, 18)) ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 2, 18)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) function f(p: I) { return f }; ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->p : Symbol(p, Decl(recursiveIdenticalOverloadResolution.ts, 5, 14)) ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>p : Symbol(p, Decl(recursiveIdenticalOverloadResolution.ts, 4, 14)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) var i: I; ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 7, 6)) ->I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 1, 10)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 6, 6)) +>I : Symbol(I, Decl(recursiveIdenticalOverloadResolution.ts, 0, 10)) f(i); ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 7, 6)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 6, 6)) f(f(i)); ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 7, 6)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 6, 6)) f((f(f(i)))); ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 3, 29)) ->i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 7, 6)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>f : Symbol(f, Decl(recursiveIdenticalOverloadResolution.ts, 2, 29)) +>i : Symbol(i, Decl(recursiveIdenticalOverloadResolution.ts, 6, 6)) } diff --git a/tests/baselines/reference/recursiveIdenticalOverloadResolution.types b/tests/baselines/reference/recursiveIdenticalOverloadResolution.types index e2ec96b1c82b6..6308fceee37cd 100644 --- a/tests/baselines/reference/recursiveIdenticalOverloadResolution.types +++ b/tests/baselines/reference/recursiveIdenticalOverloadResolution.types @@ -1,5 +1,4 @@ === tests/cases/compiler/recursiveIdenticalOverloadResolution.ts === - module M { >M : typeof M diff --git a/tests/baselines/reference/recursiveInheritance.errors.txt b/tests/baselines/reference/recursiveInheritance.errors.txt index c724afc5a0e6e..2758d08a29779 100644 --- a/tests/baselines/reference/recursiveInheritance.errors.txt +++ b/tests/baselines/reference/recursiveInheritance.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/recursiveInheritance.ts(2,11): error TS2310: Type 'I5' recursively references itself as a base type. -tests/cases/compiler/recursiveInheritance.ts(6,11): error TS2310: Type 'i8' recursively references itself as a base type. +tests/cases/compiler/recursiveInheritance.ts(1,11): error TS2310: Type 'I5' recursively references itself as a base type. +tests/cases/compiler/recursiveInheritance.ts(5,11): error TS2310: Type 'i8' recursively references itself as a base type. ==== tests/cases/compiler/recursiveInheritance.ts (2 errors) ==== - interface I5 extends I5 { // error ~~ !!! error TS2310: Type 'I5' recursively references itself as a base type. diff --git a/tests/baselines/reference/recursiveInheritance.js b/tests/baselines/reference/recursiveInheritance.js index 820bee28bcdaa..10153cbd1cbc5 100644 --- a/tests/baselines/reference/recursiveInheritance.js +++ b/tests/baselines/reference/recursiveInheritance.js @@ -1,5 +1,4 @@ //// [recursiveInheritance.ts] - interface I5 extends I5 { // error foo():void; } diff --git a/tests/baselines/reference/recursiveMappedTypes.errors.txt b/tests/baselines/reference/recursiveMappedTypes.errors.txt index 3dd6a55cf8cdb..440825f531949 100644 --- a/tests/baselines/reference/recursiveMappedTypes.errors.txt +++ b/tests/baselines/reference/recursiveMappedTypes.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(4,6): error TS2456: Type alias 'Recurse' circularly references itself. -tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(8,6): error TS2456: Type alias 'Recurse1' circularly references itself. -tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(12,6): error TS2456: Type alias 'Recurse2' circularly references itself. +tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(3,6): error TS2456: Type alias 'Recurse' circularly references itself. +tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(7,6): error TS2456: Type alias 'Recurse1' circularly references itself. +tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(11,6): error TS2456: Type alias 'Recurse2' circularly references itself. ==== tests/cases/conformance/types/mapped/recursiveMappedTypes.ts (3 errors) ==== - // Recursive mapped types simply appear empty type Recurse = { diff --git a/tests/baselines/reference/recursiveMappedTypes.js b/tests/baselines/reference/recursiveMappedTypes.js index dfe69457ed72e..5061070866428 100644 --- a/tests/baselines/reference/recursiveMappedTypes.js +++ b/tests/baselines/reference/recursiveMappedTypes.js @@ -1,5 +1,4 @@ //// [recursiveMappedTypes.ts] - // Recursive mapped types simply appear empty type Recurse = { diff --git a/tests/baselines/reference/recursiveMods.js b/tests/baselines/reference/recursiveMods.js index 3c41bed5e62ba..f9f48a4a891ce 100644 --- a/tests/baselines/reference/recursiveMods.js +++ b/tests/baselines/reference/recursiveMods.js @@ -1,5 +1,4 @@ //// [recursiveMods.ts] - export module Foo { export class C {} } diff --git a/tests/baselines/reference/recursiveMods.symbols b/tests/baselines/reference/recursiveMods.symbols index 5f6d6f87721eb..1e7e8fa1c8418 100644 --- a/tests/baselines/reference/recursiveMods.symbols +++ b/tests/baselines/reference/recursiveMods.symbols @@ -1,45 +1,44 @@ === tests/cases/compiler/recursiveMods.ts === - export module Foo { ->Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 3, 1)) +>Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 2, 1)) export class C {} ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) } export module Foo { ->Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 3, 1)) +>Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 2, 1)) function Bar() : C { ->Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19)) ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) +>Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) if (true) { return Bar();} ->Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19)) +>Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19)) return new C(); ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) } function Baz() : C { ->Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2)) ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) +>Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) var c = Baz(); ->c : Symbol(c, Decl(recursiveMods.ts, 13, 5)) ->Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2)) +>c : Symbol(c, Decl(recursiveMods.ts, 12, 5)) +>Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2)) return Bar(); ->Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19)) +>Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19)) } function Gar() { ->Gar : Symbol(Gar, Decl(recursiveMods.ts, 15, 2)) +>Gar : Symbol(Gar, Decl(recursiveMods.ts, 14, 2)) var c : C = Baz(); ->c : Symbol(c, Decl(recursiveMods.ts, 18, 5)) ->C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) ->Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2)) +>c : Symbol(c, Decl(recursiveMods.ts, 17, 5)) +>C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) +>Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2)) return; } diff --git a/tests/baselines/reference/recursiveMods.types b/tests/baselines/reference/recursiveMods.types index 45e803fee1e42..8ffd41838c048 100644 --- a/tests/baselines/reference/recursiveMods.types +++ b/tests/baselines/reference/recursiveMods.types @@ -1,5 +1,4 @@ === tests/cases/compiler/recursiveMods.ts === - export module Foo { >Foo : typeof Foo diff --git a/tests/baselines/reference/recursiveTypeRelations.errors.txt b/tests/baselines/reference/recursiveTypeRelations.errors.txt new file mode 100644 index 0000000000000..f29d5742185ae --- /dev/null +++ b/tests/baselines/reference/recursiveTypeRelations.errors.txt @@ -0,0 +1,48 @@ +tests/cases/compiler/recursiveTypeRelations.ts(8,5): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/compiler/recursiveTypeRelations.ts(27,38): error TS2304: Cannot find name 'ClassNameObject'. +tests/cases/compiler/recursiveTypeRelations.ts(27,61): error TS2304: Cannot find name 'ClassNameObject'. + + +==== tests/cases/compiler/recursiveTypeRelations.ts (3 errors) ==== + // Repro from #14896 + + type Attributes = { + [Key in Keys]: string; + } + + class Query> { + multiply>(x: B): Query; + ~~~~~~~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + } + + // Repro from #14940 + + type ClassName = keyof S; + type ClassNameMap = { [K in keyof S]?: boolean } + type ClassNameObjectMap = object & ClassNameMap; + type ClassNameArg = ClassName | ClassNameObjectMap; + + export function css(styles: S, ...classNames: ClassNameArg[]): string { + const args = classNames.map(arg => { + if (arg == null) { + return null; + } + if (typeof arg == "string") { + return styles[arg]; + } + if (typeof arg == "object") { + return Object.keys(arg).reduce((obj: ClassNameObject, key: keyof S) => { + ~~~~~~~~~~~~~~~ +!!! error TS2304: Cannot find name 'ClassNameObject'. + ~~~~~~~~~~~~~~~ +!!! error TS2304: Cannot find name 'ClassNameObject'. + const exportedClassName = styles[key]; + obj[exportedClassName] = (arg as ClassNameMap)[key]; + return obj; + }, {}); + } + }); + return ""; + } + \ No newline at end of file diff --git a/tests/baselines/reference/recursiveTypeRelations.js b/tests/baselines/reference/recursiveTypeRelations.js new file mode 100644 index 0000000000000..d006c9482d833 --- /dev/null +++ b/tests/baselines/reference/recursiveTypeRelations.js @@ -0,0 +1,70 @@ +//// [recursiveTypeRelations.ts] +// Repro from #14896 + +type Attributes = { + [Key in Keys]: string; +} + +class Query> { + multiply>(x: B): Query; +} + +// Repro from #14940 + +type ClassName = keyof S; +type ClassNameMap = { [K in keyof S]?: boolean } +type ClassNameObjectMap = object & ClassNameMap; +type ClassNameArg = ClassName | ClassNameObjectMap; + +export function css(styles: S, ...classNames: ClassNameArg[]): string { + const args = classNames.map(arg => { + if (arg == null) { + return null; + } + if (typeof arg == "string") { + return styles[arg]; + } + if (typeof arg == "object") { + return Object.keys(arg).reduce((obj: ClassNameObject, key: keyof S) => { + const exportedClassName = styles[key]; + obj[exportedClassName] = (arg as ClassNameMap)[key]; + return obj; + }, {}); + } + }); + return ""; +} + + +//// [recursiveTypeRelations.js] +"use strict"; +// Repro from #14896 +exports.__esModule = true; +var Query = (function () { + function Query() { + } + return Query; +}()); +function css(styles) { + var classNames = []; + for (var _i = 1; _i < arguments.length; _i++) { + classNames[_i - 1] = arguments[_i]; + } + var args = classNames.map(function (arg) { + if (arg == null) { + return null; + } + if (typeof arg == "string") { + return styles[arg]; + } + if (typeof arg == "object") { + return Object.keys(arg).reduce(function (obj, key) { + var exportedClassName = styles[key]; + obj[exportedClassName] = arg[key]; + return obj; + }, {}); + } + }); + return ""; +} +exports.css = css; diff --git a/tests/baselines/reference/redeclareParameterInCatchBlock.errors.txt b/tests/baselines/reference/redeclareParameterInCatchBlock.errors.txt index 9b1cad852abeb..c101e131c7d0c 100644 --- a/tests/baselines/reference/redeclareParameterInCatchBlock.errors.txt +++ b/tests/baselines/reference/redeclareParameterInCatchBlock.errors.txt @@ -1,12 +1,11 @@ -tests/cases/compiler/redeclareParameterInCatchBlock.ts(5,11): error TS2492: Cannot redeclare identifier 'e' in catch clause. -tests/cases/compiler/redeclareParameterInCatchBlock.ts(11,9): error TS2492: Cannot redeclare identifier 'e' in catch clause. -tests/cases/compiler/redeclareParameterInCatchBlock.ts(17,15): error TS2492: Cannot redeclare identifier 'b' in catch clause. -tests/cases/compiler/redeclareParameterInCatchBlock.ts(22,15): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/redeclareParameterInCatchBlock.ts(22,21): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(4,11): error TS2492: Cannot redeclare identifier 'e' in catch clause. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(10,9): error TS2492: Cannot redeclare identifier 'e' in catch clause. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(16,15): error TS2492: Cannot redeclare identifier 'b' in catch clause. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(21,15): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/redeclareParameterInCatchBlock.ts(21,21): error TS2451: Cannot redeclare block-scoped variable 'x'. ==== tests/cases/compiler/redeclareParameterInCatchBlock.ts (5 errors) ==== - try { } catch(e) { diff --git a/tests/baselines/reference/redeclareParameterInCatchBlock.js b/tests/baselines/reference/redeclareParameterInCatchBlock.js index 9fafe0b17be1b..8ccfb16142b22 100644 --- a/tests/baselines/reference/redeclareParameterInCatchBlock.js +++ b/tests/baselines/reference/redeclareParameterInCatchBlock.js @@ -1,5 +1,4 @@ //// [redeclareParameterInCatchBlock.ts] - try { } catch(e) { diff --git a/tests/baselines/reference/reexportClassDefinition.symbols b/tests/baselines/reference/reexportClassDefinition.symbols index 521336579859f..ba1ead2fbc9ab 100644 --- a/tests/baselines/reference/reexportClassDefinition.symbols +++ b/tests/baselines/reference/reexportClassDefinition.symbols @@ -4,7 +4,9 @@ import foo2 = require('./foo2') class x extends foo2.x {} >x : Symbol(x, Decl(foo3.ts, 0, 31)) +>foo2.x : Symbol(x, Decl(foo2.ts, 2, 10)) >foo2 : Symbol(foo2, Decl(foo3.ts, 0, 0)) +>x : Symbol(x, Decl(foo2.ts, 2, 10)) === tests/cases/conformance/externalModules/foo1.ts === diff --git a/tests/baselines/reference/relativeNamesInClassicResolution.errors.txt b/tests/baselines/reference/relativeNamesInClassicResolution.errors.txt index 65a427753318a..228c395cf119a 100644 --- a/tests/baselines/reference/relativeNamesInClassicResolution.errors.txt +++ b/tests/baselines/reference/relativeNamesInClassicResolution.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/somefolder/a.ts(2,17): error TS2307: Cannot find module './b'. +tests/cases/compiler/somefolder/a.ts(1,17): error TS2307: Cannot find module './b'. ==== tests/cases/compiler/somefolder/a.ts (1 errors) ==== - import {x} from "./b" ~~~~~ !!! error TS2307: Cannot find module './b'. diff --git a/tests/baselines/reference/relativeNamesInClassicResolution.js b/tests/baselines/reference/relativeNamesInClassicResolution.js index cf43ec2a5ca3e..cb7616243ef4e 100644 --- a/tests/baselines/reference/relativeNamesInClassicResolution.js +++ b/tests/baselines/reference/relativeNamesInClassicResolution.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/relativeNamesInClassicResolution.ts] //// //// [a.ts] - import {x} from "./b" //// [b.ts] diff --git a/tests/baselines/reference/requireOfAnEmptyFile1.js b/tests/baselines/reference/requireOfAnEmptyFile1.js index a1e6dbbc44730..e792d9fa763f5 100644 --- a/tests/baselines/reference/requireOfAnEmptyFile1.js +++ b/tests/baselines/reference/requireOfAnEmptyFile1.js @@ -10,6 +10,6 @@ import fs = require('./requireOfAnEmptyFile1_b'); //// [requireOfAnEmptyFile1_b.js] //// [requireOfAnEmptyFile1_a.js] -//requireOfAnEmptyFile1 "use strict"; +//requireOfAnEmptyFile1 exports.__esModule = true; diff --git a/tests/baselines/reference/restUnion2.js b/tests/baselines/reference/restUnion2.js index 44a0acfbcf825..71f4b06cfef48 100644 --- a/tests/baselines/reference/restUnion2.js +++ b/tests/baselines/reference/restUnion2.js @@ -1,5 +1,4 @@ //// [restUnion2.ts] - declare const undefinedUnion: { n: number } | undefined; var rest2: { n: number }; var {...rest2 } = undefinedUnion; diff --git a/tests/baselines/reference/restUnion2.symbols b/tests/baselines/reference/restUnion2.symbols index 20a113a23b498..54ac47f06940b 100644 --- a/tests/baselines/reference/restUnion2.symbols +++ b/tests/baselines/reference/restUnion2.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/restUnion2.ts === - declare const undefinedUnion: { n: number } | undefined; ->undefinedUnion : Symbol(undefinedUnion, Decl(restUnion2.ts, 1, 13)) ->n : Symbol(n, Decl(restUnion2.ts, 1, 31)) +>undefinedUnion : Symbol(undefinedUnion, Decl(restUnion2.ts, 0, 13)) +>n : Symbol(n, Decl(restUnion2.ts, 0, 31)) var rest2: { n: number }; ->rest2 : Symbol(rest2, Decl(restUnion2.ts, 2, 3), Decl(restUnion2.ts, 3, 5)) ->n : Symbol(n, Decl(restUnion2.ts, 2, 12)) +>rest2 : Symbol(rest2, Decl(restUnion2.ts, 1, 3), Decl(restUnion2.ts, 2, 5)) +>n : Symbol(n, Decl(restUnion2.ts, 1, 12)) var {...rest2 } = undefinedUnion; ->rest2 : Symbol(rest2, Decl(restUnion2.ts, 2, 3), Decl(restUnion2.ts, 3, 5)) ->undefinedUnion : Symbol(undefinedUnion, Decl(restUnion2.ts, 1, 13)) +>rest2 : Symbol(rest2, Decl(restUnion2.ts, 1, 3), Decl(restUnion2.ts, 2, 5)) +>undefinedUnion : Symbol(undefinedUnion, Decl(restUnion2.ts, 0, 13)) declare const nullUnion: { n: number } | null; ->nullUnion : Symbol(nullUnion, Decl(restUnion2.ts, 6, 13)) ->n : Symbol(n, Decl(restUnion2.ts, 6, 26)) +>nullUnion : Symbol(nullUnion, Decl(restUnion2.ts, 5, 13)) +>n : Symbol(n, Decl(restUnion2.ts, 5, 26)) var rest3: { n: number }; ->rest3 : Symbol(rest3, Decl(restUnion2.ts, 7, 3), Decl(restUnion2.ts, 8, 5)) ->n : Symbol(n, Decl(restUnion2.ts, 7, 12)) +>rest3 : Symbol(rest3, Decl(restUnion2.ts, 6, 3), Decl(restUnion2.ts, 7, 5)) +>n : Symbol(n, Decl(restUnion2.ts, 6, 12)) var {...rest3 } = nullUnion; ->rest3 : Symbol(rest3, Decl(restUnion2.ts, 7, 3), Decl(restUnion2.ts, 8, 5)) ->nullUnion : Symbol(nullUnion, Decl(restUnion2.ts, 6, 13)) +>rest3 : Symbol(rest3, Decl(restUnion2.ts, 6, 3), Decl(restUnion2.ts, 7, 5)) +>nullUnion : Symbol(nullUnion, Decl(restUnion2.ts, 5, 13)) declare const nullAndUndefinedUnion: null | undefined; ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(restUnion2.ts, 11, 13)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(restUnion2.ts, 10, 13)) var rest4: { }; ->rest4 : Symbol(rest4, Decl(restUnion2.ts, 12, 3), Decl(restUnion2.ts, 13, 5)) +>rest4 : Symbol(rest4, Decl(restUnion2.ts, 11, 3), Decl(restUnion2.ts, 12, 5)) var {...rest4 } = nullAndUndefinedUnion; ->rest4 : Symbol(rest4, Decl(restUnion2.ts, 12, 3), Decl(restUnion2.ts, 13, 5)) ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(restUnion2.ts, 11, 13)) +>rest4 : Symbol(rest4, Decl(restUnion2.ts, 11, 3), Decl(restUnion2.ts, 12, 5)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(restUnion2.ts, 10, 13)) declare const unionWithIntersection: ({ n: number } & { s: string }) & undefined | null; ->unionWithIntersection : Symbol(unionWithIntersection, Decl(restUnion2.ts, 15, 13)) ->n : Symbol(n, Decl(restUnion2.ts, 15, 39)) ->s : Symbol(s, Decl(restUnion2.ts, 15, 55)) +>unionWithIntersection : Symbol(unionWithIntersection, Decl(restUnion2.ts, 14, 13)) +>n : Symbol(n, Decl(restUnion2.ts, 14, 39)) +>s : Symbol(s, Decl(restUnion2.ts, 14, 55)) var rest5: { n: number, s: string }; ->rest5 : Symbol(rest5, Decl(restUnion2.ts, 16, 3), Decl(restUnion2.ts, 17, 5)) ->n : Symbol(n, Decl(restUnion2.ts, 16, 12)) ->s : Symbol(s, Decl(restUnion2.ts, 16, 23)) +>rest5 : Symbol(rest5, Decl(restUnion2.ts, 15, 3), Decl(restUnion2.ts, 16, 5)) +>n : Symbol(n, Decl(restUnion2.ts, 15, 12)) +>s : Symbol(s, Decl(restUnion2.ts, 15, 23)) var {...rest5 } = unionWithIntersection; ->rest5 : Symbol(rest5, Decl(restUnion2.ts, 16, 3), Decl(restUnion2.ts, 17, 5)) ->unionWithIntersection : Symbol(unionWithIntersection, Decl(restUnion2.ts, 15, 13)) +>rest5 : Symbol(rest5, Decl(restUnion2.ts, 15, 3), Decl(restUnion2.ts, 16, 5)) +>unionWithIntersection : Symbol(unionWithIntersection, Decl(restUnion2.ts, 14, 13)) diff --git a/tests/baselines/reference/restUnion2.types b/tests/baselines/reference/restUnion2.types index 81b768777fd17..03c8d577e668d 100644 --- a/tests/baselines/reference/restUnion2.types +++ b/tests/baselines/reference/restUnion2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/restUnion2.ts === - declare const undefinedUnion: { n: number } | undefined; >undefinedUnion : { n: number; } | undefined >n : number diff --git a/tests/baselines/reference/returnStatement1.js b/tests/baselines/reference/returnStatement1.js index 3f5c5561b2a01..c4ccc3caddec2 100644 --- a/tests/baselines/reference/returnStatement1.js +++ b/tests/baselines/reference/returnStatement1.js @@ -1,5 +1,4 @@ //// [returnStatement1.ts] - function f() { return function (s) { var x = s; diff --git a/tests/baselines/reference/returnStatement1.symbols b/tests/baselines/reference/returnStatement1.symbols index 6727cba0df5b0..acec9f7600374 100644 --- a/tests/baselines/reference/returnStatement1.symbols +++ b/tests/baselines/reference/returnStatement1.symbols @@ -1,14 +1,13 @@ === tests/cases/compiler/returnStatement1.ts === - function f() { >f : Symbol(f, Decl(returnStatement1.ts, 0, 0)) return function (s) { ->s : Symbol(s, Decl(returnStatement1.ts, 2, 21)) +>s : Symbol(s, Decl(returnStatement1.ts, 1, 21)) var x = s; ->x : Symbol(x, Decl(returnStatement1.ts, 3, 11)) ->s : Symbol(s, Decl(returnStatement1.ts, 2, 21)) +>x : Symbol(x, Decl(returnStatement1.ts, 2, 11)) +>s : Symbol(s, Decl(returnStatement1.ts, 1, 21)) }; ("harmless extra line"); diff --git a/tests/baselines/reference/returnStatement1.types b/tests/baselines/reference/returnStatement1.types index 0c90955104394..61a2c67f8284f 100644 --- a/tests/baselines/reference/returnStatement1.types +++ b/tests/baselines/reference/returnStatement1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/returnStatement1.ts === - function f() { >f : () => (s: any) => void diff --git a/tests/baselines/reference/scannerClass2.errors.txt b/tests/baselines/reference/scannerClass2.errors.txt index e7a1765a76688..6509d05aa72e5 100644 --- a/tests/baselines/reference/scannerClass2.errors.txt +++ b/tests/baselines/reference/scannerClass2.errors.txt @@ -1,11 +1,9 @@ -tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(3,43): error TS2304: Cannot find name 'ILogger'. -tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(4,37): error TS2304: Cannot find name 'ILogger'. -tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(5,18): error TS2339: Property '_information' does not exist on type 'LoggerAdapter'. +tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(1,43): error TS2304: Cannot find name 'ILogger'. +tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(2,37): error TS2304: Cannot find name 'ILogger'. +tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts(3,18): error TS2339: Property '_information' does not exist on type 'LoggerAdapter'. ==== tests/cases/conformance/scanner/ecmascript5/scannerClass2.ts (3 errors) ==== - - export class LoggerAdapter implements ILogger { ~~~~~~~ !!! error TS2304: Cannot find name 'ILogger'. diff --git a/tests/baselines/reference/scannerClass2.js b/tests/baselines/reference/scannerClass2.js index bc489268afd5c..339098b481a19 100644 --- a/tests/baselines/reference/scannerClass2.js +++ b/tests/baselines/reference/scannerClass2.js @@ -1,6 +1,4 @@ //// [scannerClass2.ts] - - export class LoggerAdapter implements ILogger { constructor (public logger: ILogger) { this._information = this.logger.information(); diff --git a/tests/baselines/reference/scopeCheckClassProperty.js b/tests/baselines/reference/scopeCheckClassProperty.js new file mode 100644 index 0000000000000..13324e7447d1c --- /dev/null +++ b/tests/baselines/reference/scopeCheckClassProperty.js @@ -0,0 +1,26 @@ +//// [scopeCheckClassProperty.ts] +class C { + constructor() { + new A().p; // ok + } + public x = new A().p; // should also be ok +} +class A { + public p = ''; +} + + +//// [scopeCheckClassProperty.js] +var C = (function () { + function C() { + this.x = new A().p; // should also be ok + new A().p; // ok + } + return C; +}()); +var A = (function () { + function A() { + this.p = ''; + } + return A; +}()); diff --git a/tests/baselines/reference/scopeCheckClassProperty.symbols b/tests/baselines/reference/scopeCheckClassProperty.symbols new file mode 100644 index 0000000000000..bd77e5413d07a --- /dev/null +++ b/tests/baselines/reference/scopeCheckClassProperty.symbols @@ -0,0 +1,23 @@ +=== tests/cases/compiler/scopeCheckClassProperty.ts === +class C { +>C : Symbol(C, Decl(scopeCheckClassProperty.ts, 0, 0)) + + constructor() { + new A().p; // ok +>new A().p : Symbol(A.p, Decl(scopeCheckClassProperty.ts, 6, 9)) +>A : Symbol(A, Decl(scopeCheckClassProperty.ts, 5, 1)) +>p : Symbol(A.p, Decl(scopeCheckClassProperty.ts, 6, 9)) + } + public x = new A().p; // should also be ok +>x : Symbol(C.x, Decl(scopeCheckClassProperty.ts, 3, 3)) +>new A().p : Symbol(A.p, Decl(scopeCheckClassProperty.ts, 6, 9)) +>A : Symbol(A, Decl(scopeCheckClassProperty.ts, 5, 1)) +>p : Symbol(A.p, Decl(scopeCheckClassProperty.ts, 6, 9)) +} +class A { +>A : Symbol(A, Decl(scopeCheckClassProperty.ts, 5, 1)) + + public p = ''; +>p : Symbol(A.p, Decl(scopeCheckClassProperty.ts, 6, 9)) +} + diff --git a/tests/baselines/reference/scopeCheckClassProperty.types b/tests/baselines/reference/scopeCheckClassProperty.types new file mode 100644 index 0000000000000..188d1308a1822 --- /dev/null +++ b/tests/baselines/reference/scopeCheckClassProperty.types @@ -0,0 +1,26 @@ +=== tests/cases/compiler/scopeCheckClassProperty.ts === +class C { +>C : C + + constructor() { + new A().p; // ok +>new A().p : string +>new A() : A +>A : typeof A +>p : string + } + public x = new A().p; // should also be ok +>x : string +>new A().p : string +>new A() : A +>A : typeof A +>p : string +} +class A { +>A : A + + public p = ''; +>p : string +>'' : "" +} + diff --git a/tests/baselines/reference/scopeCheckStaticInitializer.errors.txt b/tests/baselines/reference/scopeCheckStaticInitializer.errors.txt new file mode 100644 index 0000000000000..c023c356a2a59 --- /dev/null +++ b/tests/baselines/reference/scopeCheckStaticInitializer.errors.txt @@ -0,0 +1,30 @@ +tests/cases/compiler/scopeCheckStaticInitializer.ts(2,38): error TS2448: Block-scoped variable 'data' used before its declaration. +tests/cases/compiler/scopeCheckStaticInitializer.ts(5,23): error TS2449: Class 'After' used before its declaration. +tests/cases/compiler/scopeCheckStaticInitializer.ts(5,29): error TS2448: Block-scoped variable 'data' used before its declaration. +tests/cases/compiler/scopeCheckStaticInitializer.ts(6,23): error TS2449: Class 'After' used before its declaration. + + +==== tests/cases/compiler/scopeCheckStaticInitializer.ts (4 errors) ==== + class X { + static illegalBeforeProperty = X.data; + ~~~~ +!!! error TS2448: Block-scoped variable 'data' used before its declaration. + static okBeforeMethod = X.method; + + static illegal2 = After.data; + ~~~~~ +!!! error TS2449: Class 'After' used before its declaration. + ~~~~ +!!! error TS2448: Block-scoped variable 'data' used before its declaration. + static illegal3 = After.method; + ~~~~~ +!!! error TS2449: Class 'After' used before its declaration. + static data = 13; + static method() { } + } + class After { + static data = 12; + static method() { }; + } + + \ No newline at end of file diff --git a/tests/baselines/reference/scopeCheckStaticInitializer.js b/tests/baselines/reference/scopeCheckStaticInitializer.js new file mode 100644 index 0000000000000..59711f073809f --- /dev/null +++ b/tests/baselines/reference/scopeCheckStaticInitializer.js @@ -0,0 +1,37 @@ +//// [scopeCheckStaticInitializer.ts] +class X { + static illegalBeforeProperty = X.data; + static okBeforeMethod = X.method; + + static illegal2 = After.data; + static illegal3 = After.method; + static data = 13; + static method() { } +} +class After { + static data = 12; + static method() { }; +} + + + +//// [scopeCheckStaticInitializer.js] +var X = (function () { + function X() { + } + X.method = function () { }; + return X; +}()); +X.illegalBeforeProperty = X.data; +X.okBeforeMethod = X.method; +X.illegal2 = After.data; +X.illegal3 = After.method; +X.data = 13; +var After = (function () { + function After() { + } + After.method = function () { }; + ; + return After; +}()); +After.data = 12; diff --git a/tests/baselines/reference/selfInLambdas.js b/tests/baselines/reference/selfInLambdas.js index f965460671659..b143c0c9e4ea3 100644 --- a/tests/baselines/reference/selfInLambdas.js +++ b/tests/baselines/reference/selfInLambdas.js @@ -1,5 +1,4 @@ //// [selfInLambdas.ts] - interface MouseEvent { x: number; y: number; diff --git a/tests/baselines/reference/selfInLambdas.symbols b/tests/baselines/reference/selfInLambdas.symbols index 8efadb7c07751..0a51113710ba9 100644 --- a/tests/baselines/reference/selfInLambdas.symbols +++ b/tests/baselines/reference/selfInLambdas.symbols @@ -1,52 +1,51 @@ === tests/cases/compiler/selfInLambdas.ts === - interface MouseEvent { >MouseEvent : Symbol(MouseEvent, Decl(selfInLambdas.ts, 0, 0)) x: number; ->x : Symbol(MouseEvent.x, Decl(selfInLambdas.ts, 1, 22)) +>x : Symbol(MouseEvent.x, Decl(selfInLambdas.ts, 0, 22)) y: number; ->y : Symbol(MouseEvent.y, Decl(selfInLambdas.ts, 2, 14)) +>y : Symbol(MouseEvent.y, Decl(selfInLambdas.ts, 1, 14)) } declare var window: Window; ->window : Symbol(window, Decl(selfInLambdas.ts, 6, 11)) ->Window : Symbol(Window, Decl(selfInLambdas.ts, 6, 27)) +>window : Symbol(window, Decl(selfInLambdas.ts, 5, 11)) +>Window : Symbol(Window, Decl(selfInLambdas.ts, 5, 27)) interface Window { ->Window : Symbol(Window, Decl(selfInLambdas.ts, 6, 27)) +>Window : Symbol(Window, Decl(selfInLambdas.ts, 5, 27)) onmousemove: (ev: MouseEvent) => any; ->onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 7, 18)) ->ev : Symbol(ev, Decl(selfInLambdas.ts, 8, 18)) +>onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 6, 18)) +>ev : Symbol(ev, Decl(selfInLambdas.ts, 7, 18)) >MouseEvent : Symbol(MouseEvent, Decl(selfInLambdas.ts, 0, 0)) } var o = { ->o : Symbol(o, Decl(selfInLambdas.ts, 11, 3)) +>o : Symbol(o, Decl(selfInLambdas.ts, 10, 3)) counter: 0, ->counter : Symbol(counter, Decl(selfInLambdas.ts, 11, 9)) +>counter : Symbol(counter, Decl(selfInLambdas.ts, 10, 9)) start: function() { ->start : Symbol(start, Decl(selfInLambdas.ts, 13, 15)) +>start : Symbol(start, Decl(selfInLambdas.ts, 12, 15)) window.onmousemove = () => { ->window.onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 7, 18)) ->window : Symbol(window, Decl(selfInLambdas.ts, 6, 11)) ->onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 7, 18)) +>window.onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 6, 18)) +>window : Symbol(window, Decl(selfInLambdas.ts, 5, 11)) +>onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 6, 18)) this.counter++ ->this.counter : Symbol(counter, Decl(selfInLambdas.ts, 11, 9)) ->this : Symbol(o, Decl(selfInLambdas.ts, 11, 7)) ->counter : Symbol(counter, Decl(selfInLambdas.ts, 11, 9)) +>this.counter : Symbol(counter, Decl(selfInLambdas.ts, 10, 9)) +>this : Symbol(o, Decl(selfInLambdas.ts, 10, 7)) +>counter : Symbol(counter, Decl(selfInLambdas.ts, 10, 9)) var f = () => this.counter; ->f : Symbol(f, Decl(selfInLambdas.ts, 19, 15)) ->this.counter : Symbol(counter, Decl(selfInLambdas.ts, 11, 9)) ->this : Symbol(o, Decl(selfInLambdas.ts, 11, 7)) ->counter : Symbol(counter, Decl(selfInLambdas.ts, 11, 9)) +>f : Symbol(f, Decl(selfInLambdas.ts, 18, 15)) +>this.counter : Symbol(counter, Decl(selfInLambdas.ts, 10, 9)) +>this : Symbol(o, Decl(selfInLambdas.ts, 10, 7)) +>counter : Symbol(counter, Decl(selfInLambdas.ts, 10, 9)) } @@ -57,39 +56,39 @@ var o = { class X { ->X : Symbol(X, Decl(selfInLambdas.ts, 25, 1)) +>X : Symbol(X, Decl(selfInLambdas.ts, 24, 1)) private value = "value"; ->value : Symbol(X.value, Decl(selfInLambdas.ts, 29, 9)) +>value : Symbol(X.value, Decl(selfInLambdas.ts, 28, 9)) public foo() { ->foo : Symbol(X.foo, Decl(selfInLambdas.ts, 30, 25)) +>foo : Symbol(X.foo, Decl(selfInLambdas.ts, 29, 25)) var outer= () => { ->outer : Symbol(outer, Decl(selfInLambdas.ts, 33, 5)) +>outer : Symbol(outer, Decl(selfInLambdas.ts, 32, 5)) var x = this.value; ->x : Symbol(x, Decl(selfInLambdas.ts, 34, 15)) ->this.value : Symbol(X.value, Decl(selfInLambdas.ts, 29, 9)) ->this : Symbol(X, Decl(selfInLambdas.ts, 25, 1)) ->value : Symbol(X.value, Decl(selfInLambdas.ts, 29, 9)) +>x : Symbol(x, Decl(selfInLambdas.ts, 33, 15)) +>this.value : Symbol(X.value, Decl(selfInLambdas.ts, 28, 9)) +>this : Symbol(X, Decl(selfInLambdas.ts, 24, 1)) +>value : Symbol(X.value, Decl(selfInLambdas.ts, 28, 9)) var inner = () => { ->inner : Symbol(inner, Decl(selfInLambdas.ts, 35, 15)) +>inner : Symbol(inner, Decl(selfInLambdas.ts, 34, 15)) var y = this.value; ->y : Symbol(y, Decl(selfInLambdas.ts, 36, 19)) ->this.value : Symbol(X.value, Decl(selfInLambdas.ts, 29, 9)) ->this : Symbol(X, Decl(selfInLambdas.ts, 25, 1)) ->value : Symbol(X.value, Decl(selfInLambdas.ts, 29, 9)) +>y : Symbol(y, Decl(selfInLambdas.ts, 35, 19)) +>this.value : Symbol(X.value, Decl(selfInLambdas.ts, 28, 9)) +>this : Symbol(X, Decl(selfInLambdas.ts, 24, 1)) +>value : Symbol(X.value, Decl(selfInLambdas.ts, 28, 9)) } inner(); ->inner : Symbol(inner, Decl(selfInLambdas.ts, 35, 15)) +>inner : Symbol(inner, Decl(selfInLambdas.ts, 34, 15)) }; outer(); ->outer : Symbol(outer, Decl(selfInLambdas.ts, 33, 5)) +>outer : Symbol(outer, Decl(selfInLambdas.ts, 32, 5)) } } diff --git a/tests/baselines/reference/selfInLambdas.types b/tests/baselines/reference/selfInLambdas.types index 251cfb2d0c3ae..a26e1e0bf286d 100644 --- a/tests/baselines/reference/selfInLambdas.types +++ b/tests/baselines/reference/selfInLambdas.types @@ -1,5 +1,4 @@ === tests/cases/compiler/selfInLambdas.ts === - interface MouseEvent { >MouseEvent : MouseEvent diff --git a/tests/baselines/reference/shebangBeforeReferences.js b/tests/baselines/reference/shebangBeforeReferences.js index 41f3cee97e1ad..4ebf692e1d513 100644 --- a/tests/baselines/reference/shebangBeforeReferences.js +++ b/tests/baselines/reference/shebangBeforeReferences.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/shebangBeforeReferences.ts] //// //// [f.d.ts] - declare module "test" { let x: number; } diff --git a/tests/baselines/reference/shebangBeforeReferences.symbols b/tests/baselines/reference/shebangBeforeReferences.symbols index 23bfe58fc6294..03e20113f589d 100644 --- a/tests/baselines/reference/shebangBeforeReferences.symbols +++ b/tests/baselines/reference/shebangBeforeReferences.symbols @@ -15,9 +15,8 @@ use(x); >x : Symbol(x, Decl(f.ts, 5, 8)) === tests/cases/compiler/f.d.ts === - declare module "test" { let x: number; ->x : Symbol(x, Decl(f.d.ts, 2, 7)) +>x : Symbol(x, Decl(f.d.ts, 1, 7)) } diff --git a/tests/baselines/reference/shebangBeforeReferences.types b/tests/baselines/reference/shebangBeforeReferences.types index 89b63a1a0b440..8b594d7650942 100644 --- a/tests/baselines/reference/shebangBeforeReferences.types +++ b/tests/baselines/reference/shebangBeforeReferences.types @@ -16,7 +16,6 @@ use(x); >x : number === tests/cases/compiler/f.d.ts === - declare module "test" { let x: number; >x : number diff --git a/tests/baselines/reference/shorthand-property-es5-es6.errors.txt b/tests/baselines/reference/shorthand-property-es5-es6.errors.txt index e54f73a4e6104..650263a08c4e4 100644 --- a/tests/baselines/reference/shorthand-property-es5-es6.errors.txt +++ b/tests/baselines/reference/shorthand-property-es5-es6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.ts(2,19): error TS2307: Cannot find module './foo'. +tests/cases/compiler/test.ts(1,19): error TS2307: Cannot find module './foo'. ==== tests/cases/compiler/test.ts (1 errors) ==== - import {foo} from './foo'; ~~~~~~~ !!! error TS2307: Cannot find module './foo'. diff --git a/tests/baselines/reference/shorthand-property-es5-es6.js b/tests/baselines/reference/shorthand-property-es5-es6.js index cbca92adb0c3f..671ce39795c3e 100644 --- a/tests/baselines/reference/shorthand-property-es5-es6.js +++ b/tests/baselines/reference/shorthand-property-es5-es6.js @@ -1,5 +1,4 @@ //// [test.ts] - import {foo} from './foo'; const baz = 42; const bar = { foo, baz }; diff --git a/tests/baselines/reference/shorthand-property-es6-amd.errors.txt b/tests/baselines/reference/shorthand-property-es6-amd.errors.txt index e54f73a4e6104..650263a08c4e4 100644 --- a/tests/baselines/reference/shorthand-property-es6-amd.errors.txt +++ b/tests/baselines/reference/shorthand-property-es6-amd.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.ts(2,19): error TS2307: Cannot find module './foo'. +tests/cases/compiler/test.ts(1,19): error TS2307: Cannot find module './foo'. ==== tests/cases/compiler/test.ts (1 errors) ==== - import {foo} from './foo'; ~~~~~~~ !!! error TS2307: Cannot find module './foo'. diff --git a/tests/baselines/reference/shorthand-property-es6-amd.js b/tests/baselines/reference/shorthand-property-es6-amd.js index 0935606ca5dc5..9469357eea24d 100644 --- a/tests/baselines/reference/shorthand-property-es6-amd.js +++ b/tests/baselines/reference/shorthand-property-es6-amd.js @@ -1,5 +1,4 @@ //// [test.ts] - import {foo} from './foo'; const baz = 42; const bar = { foo, baz }; diff --git a/tests/baselines/reference/shorthand-property-es6-es6.errors.txt b/tests/baselines/reference/shorthand-property-es6-es6.errors.txt index e54f73a4e6104..650263a08c4e4 100644 --- a/tests/baselines/reference/shorthand-property-es6-es6.errors.txt +++ b/tests/baselines/reference/shorthand-property-es6-es6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/test.ts(2,19): error TS2307: Cannot find module './foo'. +tests/cases/compiler/test.ts(1,19): error TS2307: Cannot find module './foo'. ==== tests/cases/compiler/test.ts (1 errors) ==== - import {foo} from './foo'; ~~~~~~~ !!! error TS2307: Cannot find module './foo'. diff --git a/tests/baselines/reference/shorthand-property-es6-es6.js b/tests/baselines/reference/shorthand-property-es6-es6.js index eff67c879cc18..42c80db10a0f1 100644 --- a/tests/baselines/reference/shorthand-property-es6-es6.js +++ b/tests/baselines/reference/shorthand-property-es6-es6.js @@ -1,5 +1,4 @@ //// [test.ts] - import {foo} from './foo'; const baz = 42; const bar = { foo, baz }; diff --git a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.js b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.js index b61620c8eb5c8..86efc8d77d14c 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.js +++ b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.js @@ -1,5 +1,4 @@ //// [shorthandOfExportedEntity01_targetES2015_CommonJS.ts] - export const test = "test"; export function foo () { diff --git a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.symbols b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.symbols index 341d40bc5429e..83cd2dc75cadd 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.symbols +++ b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/shorthandOfExportedEntity01_targetES2015_CommonJS.ts === - export const test = "test"; ->test : Symbol(test, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 1, 12)) +>test : Symbol(test, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 0, 12)) export function foo () { ->foo : Symbol(foo, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 1, 27)) +>foo : Symbol(foo, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 0, 27)) const x = { test }; ->x : Symbol(x, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 4, 7)) ->test : Symbol(test, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 4, 13)) +>x : Symbol(x, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 3, 7)) +>test : Symbol(test, Decl(shorthandOfExportedEntity01_targetES2015_CommonJS.ts, 3, 13)) } diff --git a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.types b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.types index f299632b3efcf..2959acfeb64ec 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.types +++ b/tests/baselines/reference/shorthandOfExportedEntity01_targetES2015_CommonJS.types @@ -1,5 +1,4 @@ === tests/cases/compiler/shorthandOfExportedEntity01_targetES2015_CommonJS.ts === - export const test = "test"; >test : "test" >"test" : "test" diff --git a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.js b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.js index 9c63ca6aa2811..295472152854f 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.js +++ b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.js @@ -1,5 +1,4 @@ //// [shorthandOfExportedEntity02_targetES5_CommonJS.ts] - export const test = "test"; export function foo () { diff --git a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.symbols b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.symbols index 3b0b40922c9a8..da42b1d991dfd 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.symbols +++ b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.symbols @@ -1,13 +1,12 @@ === tests/cases/compiler/shorthandOfExportedEntity02_targetES5_CommonJS.ts === - export const test = "test"; ->test : Symbol(test, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 1, 12)) +>test : Symbol(test, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 0, 12)) export function foo () { ->foo : Symbol(foo, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 1, 27)) +>foo : Symbol(foo, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 0, 27)) const x = { test }; ->x : Symbol(x, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 4, 7)) ->test : Symbol(test, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 4, 13)) +>x : Symbol(x, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 3, 7)) +>test : Symbol(test, Decl(shorthandOfExportedEntity02_targetES5_CommonJS.ts, 3, 13)) } diff --git a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.types b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.types index effe8e89da409..146a32e14a50f 100644 --- a/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.types +++ b/tests/baselines/reference/shorthandOfExportedEntity02_targetES5_CommonJS.types @@ -1,5 +1,4 @@ === tests/cases/compiler/shorthandOfExportedEntity02_targetES5_CommonJS.ts === - export const test = "test"; >test : "test" >"test" : "test" diff --git a/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.errors.txt index 35fc45421c4ee..22522208ea890 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.errors.txt +++ b/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.errors.txt @@ -2,7 +2,6 @@ tests/cases/compiler/test.ts(2,19): error TS2307: Cannot find module './missingM ==== tests/cases/compiler/existingModule.ts (0 errors) ==== - export var x = 1; ==== tests/cases/compiler/test.ts (1 errors) ==== diff --git a/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.js b/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.js index f5c7a53f307ad..6da26a63f6b5e 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.js +++ b/tests/baselines/reference/shorthandPropertyAssignmentInES6Module.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/shorthandPropertyAssignmentInES6Module.ts] //// //// [existingModule.ts] - export var x = 1; //// [test.ts] diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt index ce029a49f1815..1225f9ab2ce60 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt @@ -1,26 +1,24 @@ -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(16,9): error TS2459: Type '{}' has no property 's1' and no string index signature. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(22,9): error TS2459: Type '{}' has no property 's1' and no string index signature. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(40,9): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(46,12): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(72,5): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(77,8): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(77,8): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(82,5): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(82,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(14,9): error TS2459: Type '{}' has no property 's1' and no string index signature. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(20,9): error TS2459: Type '{}' has no property 's1' and no string index signature. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(38,9): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(44,12): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(70,5): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(75,8): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(75,8): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(80,5): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(80,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. Types of property 'x' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,8): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,8): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(85,8): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(85,8): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(85,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. Types of property 'x' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(113,12): error TS2304: Cannot find name 's'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(113,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(111,12): error TS2304: Cannot find name 's'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(111,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. ==== tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts (14 errors) ==== - - (function() { var s0; for ({ s0 = 5 } of [{ s0: 1 }]) { diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js index 6be02246e3937..ca874652de8ef 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js @@ -1,6 +1,4 @@ //// [shorthandPropertyAssignmentsInDestructuring.ts] - - (function() { var s0; for ({ s0 = 5 } of [{ s0: 1 }]) { diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt index 0a61eed7326ac..acff36b6d1f3f 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt @@ -1,26 +1,24 @@ -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(16,9): error TS2459: Type '{}' has no property 's1' and no string index signature. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(22,9): error TS2459: Type '{}' has no property 's1' and no string index signature. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(40,9): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(46,12): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(72,5): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(77,8): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(77,8): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(82,5): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(82,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(14,9): error TS2459: Type '{}' has no property 's1' and no string index signature. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(20,9): error TS2459: Type '{}' has no property 's1' and no string index signature. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(38,9): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(44,12): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(70,5): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(75,8): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(75,8): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(80,5): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(80,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. Types of property 'x' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,8): error TS2322: Type '5' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,8): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(85,8): error TS2322: Type '5' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(85,8): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(85,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. Types of property 'x' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(113,12): error TS2304: Cannot find name 's'. -tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(113,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(111,12): error TS2304: Cannot find name 's'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(111,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. ==== tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts (14 errors) ==== - - (function() { var s0; for ({ s0 = 5 } of [{ s0: 1 }]) { diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js index 11068708110a4..a7c5089165e91 100644 --- a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js @@ -1,6 +1,4 @@ //// [shorthandPropertyAssignmentsInDestructuring_ES6.ts] - - (function() { var s0; for ({ s0 = 5 } of [{ s0: 1 }]) { diff --git a/tests/baselines/reference/sourceMap-FileWithComments.js b/tests/baselines/reference/sourceMap-FileWithComments.js index dd2131889afcc..d2287d0bea290 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.js +++ b/tests/baselines/reference/sourceMap-FileWithComments.js @@ -1,5 +1,4 @@ //// [sourceMap-FileWithComments.ts] - // Interface interface IPoint { getDist(): number; diff --git a/tests/baselines/reference/sourceMap-FileWithComments.js.map b/tests/baselines/reference/sourceMap-FileWithComments.js.map index 11d0f52a18d4e..a85ce154f1175 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.js.map +++ b/tests/baselines/reference/sourceMap-FileWithComments.js.map @@ -1,2 +1,2 @@ //// [sourceMap-FileWithComments.js.map] -{"version":3,"file":"sourceMap-FileWithComments.js","sourceRoot":"","sources":["sourceMap-FileWithComments.ts"],"names":[],"mappings":"AAMA,SAAS;AACT,IAAO,MAAM,CAwBZ;AAxBD,WAAO,MAAM;IAET,QAAQ;IACR;QACI,cAAc;QACd,eAAmB,CAAS,EAAS,CAAS;YAA3B,MAAC,GAAD,CAAC,CAAQ;YAAS,MAAC,GAAD,CAAC,CAAQ;QAAI,CAAC;QAEnD,kBAAkB;QAClB,uBAAO,GAAP,cAAY,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAItE,YAAC;IAAD,CAAC,AATD;IAOI,gBAAgB;IACT,YAAM,GAAG,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IARvB,YAAK,QASjB,CAAA;IAED,+BAA+B;IAC/B,IAAI,CAAC,GAAG,EAAE,CAAC;IAEX;IACA,CAAC;IADe,UAAG,MAClB,CAAA;IAED;;MAEE;IACF,IAAI,CAAC,GAAG,EAAE,CAAC;AACf,CAAC,EAxBM,MAAM,KAAN,MAAM,QAwBZ;AAED,qBAAqB;AACrB,IAAI,CAAC,GAAW,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACvC,IAAI,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC"} \ No newline at end of file +{"version":3,"file":"sourceMap-FileWithComments.js","sourceRoot":"","sources":["sourceMap-FileWithComments.ts"],"names":[],"mappings":"AAKA,SAAS;AACT,IAAO,MAAM,CAwBZ;AAxBD,WAAO,MAAM;IAET,QAAQ;IACR;QACI,cAAc;QACd,eAAmB,CAAS,EAAS,CAAS;YAA3B,MAAC,GAAD,CAAC,CAAQ;YAAS,MAAC,GAAD,CAAC,CAAQ;QAAI,CAAC;QAEnD,kBAAkB;QAClB,uBAAO,GAAP,cAAY,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAItE,YAAC;IAAD,CAAC,AATD;IAOI,gBAAgB;IACT,YAAM,GAAG,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IARvB,YAAK,QASjB,CAAA;IAED,+BAA+B;IAC/B,IAAI,CAAC,GAAG,EAAE,CAAC;IAEX;IACA,CAAC;IADe,UAAG,MAClB,CAAA;IAED;;MAEE;IACF,IAAI,CAAC,GAAG,EAAE,CAAC;AACf,CAAC,EAxBM,MAAM,KAAN,MAAM,QAwBZ;AAED,qBAAqB;AACrB,IAAI,CAAC,GAAW,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACvC,IAAI,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-FileWithComments.sourcemap.txt b/tests/baselines/reference/sourceMap-FileWithComments.sourcemap.txt index fc822f1cfe00a..9e81aba718aa1 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.sourcemap.txt +++ b/tests/baselines/reference/sourceMap-FileWithComments.sourcemap.txt @@ -12,16 +12,15 @@ sourceFile:sourceMap-FileWithComments.ts 1 > 2 >^^^^^^^^^ 3 > ^^^-> -1 > - >// Interface +1 >// Interface >interface IPoint { > getDist(): number; >} > > 2 >// Module -1 >Emitted(1, 1) Source(7, 1) + SourceIndex(0) -2 >Emitted(1, 10) Source(7, 10) + SourceIndex(0) +1 >Emitted(1, 1) Source(6, 1) + SourceIndex(0) +2 >Emitted(1, 10) Source(6, 10) + SourceIndex(0) --- >>>var Shapes; 1-> @@ -58,10 +57,10 @@ sourceFile:sourceMap-FileWithComments.ts > */ > var b = 10; > } -1->Emitted(2, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(2, 5) Source(8, 8) + SourceIndex(0) -3 >Emitted(2, 11) Source(8, 14) + SourceIndex(0) -4 >Emitted(2, 12) Source(32, 2) + SourceIndex(0) +1->Emitted(2, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(2, 5) Source(7, 8) + SourceIndex(0) +3 >Emitted(2, 11) Source(7, 14) + SourceIndex(0) +4 >Emitted(2, 12) Source(31, 2) + SourceIndex(0) --- >>>(function (Shapes) { 1-> @@ -70,9 +69,9 @@ sourceFile:sourceMap-FileWithComments.ts 1-> 2 >module 3 > Shapes -1->Emitted(3, 1) Source(8, 1) + SourceIndex(0) -2 >Emitted(3, 12) Source(8, 8) + SourceIndex(0) -3 >Emitted(3, 18) Source(8, 14) + SourceIndex(0) +1->Emitted(3, 1) Source(7, 1) + SourceIndex(0) +2 >Emitted(3, 12) Source(7, 8) + SourceIndex(0) +3 >Emitted(3, 18) Source(7, 14) + SourceIndex(0) --- >>> // Class 1 >^^^^ @@ -82,15 +81,15 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 > // Class -1 >Emitted(4, 5) Source(10, 5) + SourceIndex(0) -2 >Emitted(4, 13) Source(10, 13) + SourceIndex(0) +1 >Emitted(4, 5) Source(9, 5) + SourceIndex(0) +2 >Emitted(4, 13) Source(9, 13) + SourceIndex(0) --- >>> var Point = (function () { 1->^^^^ 2 > ^^^^^^^^^^^^^^^^^^^-> 1-> > -1->Emitted(5, 5) Source(11, 5) + SourceIndex(0) +1->Emitted(5, 5) Source(10, 5) + SourceIndex(0) --- >>> // Constructor 1->^^^^^^^^ @@ -99,8 +98,8 @@ sourceFile:sourceMap-FileWithComments.ts 1->export class Point implements IPoint { > 2 > // Constructor -1->Emitted(6, 9) Source(12, 9) + SourceIndex(0) -2 >Emitted(6, 23) Source(12, 23) + SourceIndex(0) +1->Emitted(6, 9) Source(11, 9) + SourceIndex(0) +2 >Emitted(6, 23) Source(11, 23) + SourceIndex(0) --- >>> function Point(x, y) { 1->^^^^^^^^ @@ -114,11 +113,11 @@ sourceFile:sourceMap-FileWithComments.ts 3 > x: number 4 > , public 5 > y: number -1->Emitted(7, 9) Source(13, 9) + SourceIndex(0) -2 >Emitted(7, 24) Source(13, 28) + SourceIndex(0) -3 >Emitted(7, 25) Source(13, 37) + SourceIndex(0) -4 >Emitted(7, 27) Source(13, 46) + SourceIndex(0) -5 >Emitted(7, 28) Source(13, 55) + SourceIndex(0) +1->Emitted(7, 9) Source(12, 9) + SourceIndex(0) +2 >Emitted(7, 24) Source(12, 28) + SourceIndex(0) +3 >Emitted(7, 25) Source(12, 37) + SourceIndex(0) +4 >Emitted(7, 27) Source(12, 46) + SourceIndex(0) +5 >Emitted(7, 28) Source(12, 55) + SourceIndex(0) --- >>> this.x = x; 1 >^^^^^^^^^^^^ @@ -132,11 +131,11 @@ sourceFile:sourceMap-FileWithComments.ts 3 > 4 > x 5 > : number -1 >Emitted(8, 13) Source(13, 28) + SourceIndex(0) -2 >Emitted(8, 19) Source(13, 29) + SourceIndex(0) -3 >Emitted(8, 22) Source(13, 28) + SourceIndex(0) -4 >Emitted(8, 23) Source(13, 29) + SourceIndex(0) -5 >Emitted(8, 24) Source(13, 37) + SourceIndex(0) +1 >Emitted(8, 13) Source(12, 28) + SourceIndex(0) +2 >Emitted(8, 19) Source(12, 29) + SourceIndex(0) +3 >Emitted(8, 22) Source(12, 28) + SourceIndex(0) +4 >Emitted(8, 23) Source(12, 29) + SourceIndex(0) +5 >Emitted(8, 24) Source(12, 37) + SourceIndex(0) --- >>> this.y = y; 1->^^^^^^^^^^^^ @@ -149,11 +148,11 @@ sourceFile:sourceMap-FileWithComments.ts 3 > 4 > y 5 > : number -1->Emitted(9, 13) Source(13, 46) + SourceIndex(0) -2 >Emitted(9, 19) Source(13, 47) + SourceIndex(0) -3 >Emitted(9, 22) Source(13, 46) + SourceIndex(0) -4 >Emitted(9, 23) Source(13, 47) + SourceIndex(0) -5 >Emitted(9, 24) Source(13, 55) + SourceIndex(0) +1->Emitted(9, 13) Source(12, 46) + SourceIndex(0) +2 >Emitted(9, 19) Source(12, 47) + SourceIndex(0) +3 >Emitted(9, 22) Source(12, 46) + SourceIndex(0) +4 >Emitted(9, 23) Source(12, 47) + SourceIndex(0) +5 >Emitted(9, 24) Source(12, 55) + SourceIndex(0) --- >>> } 1 >^^^^^^^^ @@ -161,8 +160,8 @@ sourceFile:sourceMap-FileWithComments.ts 3 > ^^^^^^^^^^^^^^^^^^-> 1 >) { 2 > } -1 >Emitted(10, 9) Source(13, 59) + SourceIndex(0) -2 >Emitted(10, 10) Source(13, 60) + SourceIndex(0) +1 >Emitted(10, 9) Source(12, 59) + SourceIndex(0) +2 >Emitted(10, 10) Source(12, 60) + SourceIndex(0) --- >>> // Instance member 1->^^^^^^^^ @@ -172,8 +171,8 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 > // Instance member -1->Emitted(11, 9) Source(15, 9) + SourceIndex(0) -2 >Emitted(11, 27) Source(15, 27) + SourceIndex(0) +1->Emitted(11, 9) Source(14, 9) + SourceIndex(0) +2 >Emitted(11, 27) Source(14, 27) + SourceIndex(0) --- >>> Point.prototype.getDist = function () { return Math.sqrt(this.x * this.x + this.y * this.y); }; 1->^^^^^^^^ @@ -235,35 +234,35 @@ sourceFile:sourceMap-FileWithComments.ts 27> ; 28> 29> } -1->Emitted(12, 9) Source(16, 9) + SourceIndex(0) -2 >Emitted(12, 32) Source(16, 16) + SourceIndex(0) -3 >Emitted(12, 35) Source(16, 9) + SourceIndex(0) -4 >Emitted(12, 49) Source(16, 21) + SourceIndex(0) -5 >Emitted(12, 55) Source(16, 27) + SourceIndex(0) -6 >Emitted(12, 56) Source(16, 28) + SourceIndex(0) -7 >Emitted(12, 60) Source(16, 32) + SourceIndex(0) -8 >Emitted(12, 61) Source(16, 33) + SourceIndex(0) -9 >Emitted(12, 65) Source(16, 37) + SourceIndex(0) -10>Emitted(12, 66) Source(16, 38) + SourceIndex(0) -11>Emitted(12, 70) Source(16, 42) + SourceIndex(0) -12>Emitted(12, 71) Source(16, 43) + SourceIndex(0) -13>Emitted(12, 72) Source(16, 44) + SourceIndex(0) -14>Emitted(12, 75) Source(16, 47) + SourceIndex(0) -15>Emitted(12, 79) Source(16, 51) + SourceIndex(0) -16>Emitted(12, 80) Source(16, 52) + SourceIndex(0) -17>Emitted(12, 81) Source(16, 53) + SourceIndex(0) -18>Emitted(12, 84) Source(16, 56) + SourceIndex(0) -19>Emitted(12, 88) Source(16, 60) + SourceIndex(0) -20>Emitted(12, 89) Source(16, 61) + SourceIndex(0) -21>Emitted(12, 90) Source(16, 62) + SourceIndex(0) -22>Emitted(12, 93) Source(16, 65) + SourceIndex(0) -23>Emitted(12, 97) Source(16, 69) + SourceIndex(0) -24>Emitted(12, 98) Source(16, 70) + SourceIndex(0) -25>Emitted(12, 99) Source(16, 71) + SourceIndex(0) -26>Emitted(12, 100) Source(16, 72) + SourceIndex(0) -27>Emitted(12, 101) Source(16, 73) + SourceIndex(0) -28>Emitted(12, 102) Source(16, 74) + SourceIndex(0) -29>Emitted(12, 103) Source(16, 75) + SourceIndex(0) +1->Emitted(12, 9) Source(15, 9) + SourceIndex(0) +2 >Emitted(12, 32) Source(15, 16) + SourceIndex(0) +3 >Emitted(12, 35) Source(15, 9) + SourceIndex(0) +4 >Emitted(12, 49) Source(15, 21) + SourceIndex(0) +5 >Emitted(12, 55) Source(15, 27) + SourceIndex(0) +6 >Emitted(12, 56) Source(15, 28) + SourceIndex(0) +7 >Emitted(12, 60) Source(15, 32) + SourceIndex(0) +8 >Emitted(12, 61) Source(15, 33) + SourceIndex(0) +9 >Emitted(12, 65) Source(15, 37) + SourceIndex(0) +10>Emitted(12, 66) Source(15, 38) + SourceIndex(0) +11>Emitted(12, 70) Source(15, 42) + SourceIndex(0) +12>Emitted(12, 71) Source(15, 43) + SourceIndex(0) +13>Emitted(12, 72) Source(15, 44) + SourceIndex(0) +14>Emitted(12, 75) Source(15, 47) + SourceIndex(0) +15>Emitted(12, 79) Source(15, 51) + SourceIndex(0) +16>Emitted(12, 80) Source(15, 52) + SourceIndex(0) +17>Emitted(12, 81) Source(15, 53) + SourceIndex(0) +18>Emitted(12, 84) Source(15, 56) + SourceIndex(0) +19>Emitted(12, 88) Source(15, 60) + SourceIndex(0) +20>Emitted(12, 89) Source(15, 61) + SourceIndex(0) +21>Emitted(12, 90) Source(15, 62) + SourceIndex(0) +22>Emitted(12, 93) Source(15, 65) + SourceIndex(0) +23>Emitted(12, 97) Source(15, 69) + SourceIndex(0) +24>Emitted(12, 98) Source(15, 70) + SourceIndex(0) +25>Emitted(12, 99) Source(15, 71) + SourceIndex(0) +26>Emitted(12, 100) Source(15, 72) + SourceIndex(0) +27>Emitted(12, 101) Source(15, 73) + SourceIndex(0) +28>Emitted(12, 102) Source(15, 74) + SourceIndex(0) +29>Emitted(12, 103) Source(15, 75) + SourceIndex(0) --- >>> return Point; 1 >^^^^^^^^ @@ -274,8 +273,8 @@ sourceFile:sourceMap-FileWithComments.ts > static origin = new Point(0, 0); > 2 > } -1 >Emitted(13, 9) Source(20, 5) + SourceIndex(0) -2 >Emitted(13, 21) Source(20, 6) + SourceIndex(0) +1 >Emitted(13, 9) Source(19, 5) + SourceIndex(0) +2 >Emitted(13, 21) Source(19, 6) + SourceIndex(0) --- >>> }()); 1 >^^^^ @@ -285,9 +284,9 @@ sourceFile:sourceMap-FileWithComments.ts 1 > 2 > } 3 > -1 >Emitted(14, 5) Source(20, 5) + SourceIndex(0) -2 >Emitted(14, 6) Source(20, 6) + SourceIndex(0) -3 >Emitted(14, 6) Source(11, 5) + SourceIndex(0) +1 >Emitted(14, 5) Source(19, 5) + SourceIndex(0) +2 >Emitted(14, 6) Source(19, 6) + SourceIndex(0) +3 >Emitted(14, 6) Source(10, 5) + SourceIndex(0) --- >>> // Static member 1->^^^^ @@ -302,8 +301,8 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 > // Static member -1->Emitted(15, 5) Source(18, 9) + SourceIndex(0) -2 >Emitted(15, 21) Source(18, 25) + SourceIndex(0) +1->Emitted(15, 5) Source(17, 9) + SourceIndex(0) +2 >Emitted(15, 21) Source(17, 25) + SourceIndex(0) --- >>> Point.origin = new Point(0, 0); 1->^^^^ @@ -329,17 +328,17 @@ sourceFile:sourceMap-FileWithComments.ts 9 > 0 10> ) 11> ; -1->Emitted(16, 5) Source(19, 16) + SourceIndex(0) -2 >Emitted(16, 17) Source(19, 22) + SourceIndex(0) -3 >Emitted(16, 20) Source(19, 25) + SourceIndex(0) -4 >Emitted(16, 24) Source(19, 29) + SourceIndex(0) -5 >Emitted(16, 29) Source(19, 34) + SourceIndex(0) -6 >Emitted(16, 30) Source(19, 35) + SourceIndex(0) -7 >Emitted(16, 31) Source(19, 36) + SourceIndex(0) -8 >Emitted(16, 33) Source(19, 38) + SourceIndex(0) -9 >Emitted(16, 34) Source(19, 39) + SourceIndex(0) -10>Emitted(16, 35) Source(19, 40) + SourceIndex(0) -11>Emitted(16, 36) Source(19, 41) + SourceIndex(0) +1->Emitted(16, 5) Source(18, 16) + SourceIndex(0) +2 >Emitted(16, 17) Source(18, 22) + SourceIndex(0) +3 >Emitted(16, 20) Source(18, 25) + SourceIndex(0) +4 >Emitted(16, 24) Source(18, 29) + SourceIndex(0) +5 >Emitted(16, 29) Source(18, 34) + SourceIndex(0) +6 >Emitted(16, 30) Source(18, 35) + SourceIndex(0) +7 >Emitted(16, 31) Source(18, 36) + SourceIndex(0) +8 >Emitted(16, 33) Source(18, 38) + SourceIndex(0) +9 >Emitted(16, 34) Source(18, 39) + SourceIndex(0) +10>Emitted(16, 35) Source(18, 40) + SourceIndex(0) +11>Emitted(16, 36) Source(18, 41) + SourceIndex(0) --- >>> Shapes.Point = Point; 1 >^^^^ @@ -360,10 +359,10 @@ sourceFile:sourceMap-FileWithComments.ts > static origin = new Point(0, 0); > } 4 > -1 >Emitted(17, 5) Source(11, 18) + SourceIndex(0) -2 >Emitted(17, 17) Source(11, 23) + SourceIndex(0) -3 >Emitted(17, 25) Source(20, 6) + SourceIndex(0) -4 >Emitted(17, 26) Source(20, 6) + SourceIndex(0) +1 >Emitted(17, 5) Source(10, 18) + SourceIndex(0) +2 >Emitted(17, 17) Source(10, 23) + SourceIndex(0) +3 >Emitted(17, 25) Source(19, 6) + SourceIndex(0) +4 >Emitted(17, 26) Source(19, 6) + SourceIndex(0) --- >>> // Variable comment after class 1->^^^^ @@ -372,8 +371,8 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 > // Variable comment after class -1->Emitted(18, 5) Source(22, 5) + SourceIndex(0) -2 >Emitted(18, 36) Source(22, 36) + SourceIndex(0) +1->Emitted(18, 5) Source(21, 5) + SourceIndex(0) +2 >Emitted(18, 36) Source(21, 36) + SourceIndex(0) --- >>> var a = 10; 1 >^^^^ @@ -390,12 +389,12 @@ sourceFile:sourceMap-FileWithComments.ts 4 > = 5 > 10 6 > ; -1 >Emitted(19, 5) Source(23, 5) + SourceIndex(0) -2 >Emitted(19, 9) Source(23, 9) + SourceIndex(0) -3 >Emitted(19, 10) Source(23, 10) + SourceIndex(0) -4 >Emitted(19, 13) Source(23, 13) + SourceIndex(0) -5 >Emitted(19, 15) Source(23, 15) + SourceIndex(0) -6 >Emitted(19, 16) Source(23, 16) + SourceIndex(0) +1 >Emitted(19, 5) Source(22, 5) + SourceIndex(0) +2 >Emitted(19, 9) Source(22, 9) + SourceIndex(0) +3 >Emitted(19, 10) Source(22, 10) + SourceIndex(0) +4 >Emitted(19, 13) Source(22, 13) + SourceIndex(0) +5 >Emitted(19, 15) Source(22, 15) + SourceIndex(0) +6 >Emitted(19, 16) Source(22, 16) + SourceIndex(0) --- >>> function foo() { 1->^^^^ @@ -403,7 +402,7 @@ sourceFile:sourceMap-FileWithComments.ts 1-> > > -1->Emitted(20, 5) Source(25, 5) + SourceIndex(0) +1->Emitted(20, 5) Source(24, 5) + SourceIndex(0) --- >>> } 1->^^^^ @@ -412,8 +411,8 @@ sourceFile:sourceMap-FileWithComments.ts 1->export function foo() { > 2 > } -1->Emitted(21, 5) Source(26, 5) + SourceIndex(0) -2 >Emitted(21, 6) Source(26, 6) + SourceIndex(0) +1->Emitted(21, 5) Source(25, 5) + SourceIndex(0) +2 >Emitted(21, 6) Source(25, 6) + SourceIndex(0) --- >>> Shapes.foo = foo; 1->^^^^ @@ -426,10 +425,10 @@ sourceFile:sourceMap-FileWithComments.ts 3 > () { > } 4 > -1->Emitted(22, 5) Source(25, 21) + SourceIndex(0) -2 >Emitted(22, 15) Source(25, 24) + SourceIndex(0) -3 >Emitted(22, 21) Source(26, 6) + SourceIndex(0) -4 >Emitted(22, 22) Source(26, 6) + SourceIndex(0) +1->Emitted(22, 5) Source(24, 21) + SourceIndex(0) +2 >Emitted(22, 15) Source(24, 24) + SourceIndex(0) +3 >Emitted(22, 21) Source(25, 6) + SourceIndex(0) +4 >Emitted(22, 22) Source(25, 6) + SourceIndex(0) --- >>> /** comment after function 1->^^^^ @@ -437,7 +436,7 @@ sourceFile:sourceMap-FileWithComments.ts 1-> > > -1->Emitted(23, 5) Source(28, 5) + SourceIndex(0) +1->Emitted(23, 5) Source(27, 5) + SourceIndex(0) --- >>> * this is another comment >>> */ @@ -446,7 +445,7 @@ sourceFile:sourceMap-FileWithComments.ts 1->/** comment after function > * this is another comment > */ -1->Emitted(25, 7) Source(30, 7) + SourceIndex(0) +1->Emitted(25, 7) Source(29, 7) + SourceIndex(0) --- >>> var b = 10; 1->^^^^ @@ -463,12 +462,12 @@ sourceFile:sourceMap-FileWithComments.ts 4 > = 5 > 10 6 > ; -1->Emitted(26, 5) Source(31, 5) + SourceIndex(0) -2 >Emitted(26, 9) Source(31, 9) + SourceIndex(0) -3 >Emitted(26, 10) Source(31, 10) + SourceIndex(0) -4 >Emitted(26, 13) Source(31, 13) + SourceIndex(0) -5 >Emitted(26, 15) Source(31, 15) + SourceIndex(0) -6 >Emitted(26, 16) Source(31, 16) + SourceIndex(0) +1->Emitted(26, 5) Source(30, 5) + SourceIndex(0) +2 >Emitted(26, 9) Source(30, 9) + SourceIndex(0) +3 >Emitted(26, 10) Source(30, 10) + SourceIndex(0) +4 >Emitted(26, 13) Source(30, 13) + SourceIndex(0) +5 >Emitted(26, 15) Source(30, 15) + SourceIndex(0) +6 >Emitted(26, 16) Source(30, 16) + SourceIndex(0) --- >>>})(Shapes || (Shapes = {})); 1-> @@ -510,13 +509,13 @@ sourceFile:sourceMap-FileWithComments.ts > */ > var b = 10; > } -1->Emitted(27, 1) Source(32, 1) + SourceIndex(0) -2 >Emitted(27, 2) Source(32, 2) + SourceIndex(0) -3 >Emitted(27, 4) Source(8, 8) + SourceIndex(0) -4 >Emitted(27, 10) Source(8, 14) + SourceIndex(0) -5 >Emitted(27, 15) Source(8, 8) + SourceIndex(0) -6 >Emitted(27, 21) Source(8, 14) + SourceIndex(0) -7 >Emitted(27, 29) Source(32, 2) + SourceIndex(0) +1->Emitted(27, 1) Source(31, 1) + SourceIndex(0) +2 >Emitted(27, 2) Source(31, 2) + SourceIndex(0) +3 >Emitted(27, 4) Source(7, 8) + SourceIndex(0) +4 >Emitted(27, 10) Source(7, 14) + SourceIndex(0) +5 >Emitted(27, 15) Source(7, 8) + SourceIndex(0) +6 >Emitted(27, 21) Source(7, 14) + SourceIndex(0) +7 >Emitted(27, 29) Source(31, 2) + SourceIndex(0) --- >>>/** Local Variable */ 1 > @@ -526,8 +525,8 @@ sourceFile:sourceMap-FileWithComments.ts > > 2 >/** Local Variable */ -1 >Emitted(28, 1) Source(34, 1) + SourceIndex(0) -2 >Emitted(28, 22) Source(34, 22) + SourceIndex(0) +1 >Emitted(28, 1) Source(33, 1) + SourceIndex(0) +2 >Emitted(28, 22) Source(33, 22) + SourceIndex(0) --- >>>var p = new Shapes.Point(3, 4); 1-> @@ -559,20 +558,20 @@ sourceFile:sourceMap-FileWithComments.ts 12> 4 13> ) 14> ; -1->Emitted(29, 1) Source(35, 1) + SourceIndex(0) -2 >Emitted(29, 5) Source(35, 5) + SourceIndex(0) -3 >Emitted(29, 6) Source(35, 6) + SourceIndex(0) -4 >Emitted(29, 9) Source(35, 17) + SourceIndex(0) -5 >Emitted(29, 13) Source(35, 21) + SourceIndex(0) -6 >Emitted(29, 19) Source(35, 27) + SourceIndex(0) -7 >Emitted(29, 20) Source(35, 28) + SourceIndex(0) -8 >Emitted(29, 25) Source(35, 33) + SourceIndex(0) -9 >Emitted(29, 26) Source(35, 34) + SourceIndex(0) -10>Emitted(29, 27) Source(35, 35) + SourceIndex(0) -11>Emitted(29, 29) Source(35, 37) + SourceIndex(0) -12>Emitted(29, 30) Source(35, 38) + SourceIndex(0) -13>Emitted(29, 31) Source(35, 39) + SourceIndex(0) -14>Emitted(29, 32) Source(35, 40) + SourceIndex(0) +1->Emitted(29, 1) Source(34, 1) + SourceIndex(0) +2 >Emitted(29, 5) Source(34, 5) + SourceIndex(0) +3 >Emitted(29, 6) Source(34, 6) + SourceIndex(0) +4 >Emitted(29, 9) Source(34, 17) + SourceIndex(0) +5 >Emitted(29, 13) Source(34, 21) + SourceIndex(0) +6 >Emitted(29, 19) Source(34, 27) + SourceIndex(0) +7 >Emitted(29, 20) Source(34, 28) + SourceIndex(0) +8 >Emitted(29, 25) Source(34, 33) + SourceIndex(0) +9 >Emitted(29, 26) Source(34, 34) + SourceIndex(0) +10>Emitted(29, 27) Source(34, 35) + SourceIndex(0) +11>Emitted(29, 29) Source(34, 37) + SourceIndex(0) +12>Emitted(29, 30) Source(34, 38) + SourceIndex(0) +13>Emitted(29, 31) Source(34, 39) + SourceIndex(0) +14>Emitted(29, 32) Source(34, 40) + SourceIndex(0) --- >>>var dist = p.getDist(); 1 > @@ -595,14 +594,14 @@ sourceFile:sourceMap-FileWithComments.ts 7 > getDist 8 > () 9 > ; -1 >Emitted(30, 1) Source(36, 1) + SourceIndex(0) -2 >Emitted(30, 5) Source(36, 5) + SourceIndex(0) -3 >Emitted(30, 9) Source(36, 9) + SourceIndex(0) -4 >Emitted(30, 12) Source(36, 12) + SourceIndex(0) -5 >Emitted(30, 13) Source(36, 13) + SourceIndex(0) -6 >Emitted(30, 14) Source(36, 14) + SourceIndex(0) -7 >Emitted(30, 21) Source(36, 21) + SourceIndex(0) -8 >Emitted(30, 23) Source(36, 23) + SourceIndex(0) -9 >Emitted(30, 24) Source(36, 24) + SourceIndex(0) +1 >Emitted(30, 1) Source(35, 1) + SourceIndex(0) +2 >Emitted(30, 5) Source(35, 5) + SourceIndex(0) +3 >Emitted(30, 9) Source(35, 9) + SourceIndex(0) +4 >Emitted(30, 12) Source(35, 12) + SourceIndex(0) +5 >Emitted(30, 13) Source(35, 13) + SourceIndex(0) +6 >Emitted(30, 14) Source(35, 14) + SourceIndex(0) +7 >Emitted(30, 21) Source(35, 21) + SourceIndex(0) +8 >Emitted(30, 23) Source(35, 23) + SourceIndex(0) +9 >Emitted(30, 24) Source(35, 24) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMap-FileWithComments.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-FileWithComments.symbols b/tests/baselines/reference/sourceMap-FileWithComments.symbols index e7b8c1c4b7c2f..70135a317d02e 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.symbols +++ b/tests/baselines/reference/sourceMap-FileWithComments.symbols @@ -1,78 +1,77 @@ === tests/cases/compiler/sourceMap-FileWithComments.ts === - // Interface interface IPoint { >IPoint : Symbol(IPoint, Decl(sourceMap-FileWithComments.ts, 0, 0)) getDist(): number; ->getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 2, 18)) +>getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 1, 18)) } // Module module Shapes { ->Shapes : Symbol(Shapes, Decl(sourceMap-FileWithComments.ts, 4, 1)) +>Shapes : Symbol(Shapes, Decl(sourceMap-FileWithComments.ts, 3, 1)) // Class export class Point implements IPoint { ->Point : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) +>Point : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) >IPoint : Symbol(IPoint, Decl(sourceMap-FileWithComments.ts, 0, 0)) // Constructor constructor(public x: number, public y: number) { } ->x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) +>x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) // Instance member getDist() { return Math.sqrt(this.x * this.x + this.y * this.y); } ->getDist : Symbol(Point.getDist, Decl(sourceMap-FileWithComments.ts, 12, 59)) +>getDist : Symbol(Point.getDist, Decl(sourceMap-FileWithComments.ts, 11, 59)) >Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) ->this.x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->this.x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 12, 20)) ->this.y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) ->this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) ->this.y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) ->this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 12, 37)) +>this.x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>this.x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>x : Symbol(Point.x, Decl(sourceMap-FileWithComments.ts, 11, 20)) +>this.y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) +>this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) +>this.y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) +>this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>y : Symbol(Point.y, Decl(sourceMap-FileWithComments.ts, 11, 37)) // Static member static origin = new Point(0, 0); ->origin : Symbol(Point.origin, Decl(sourceMap-FileWithComments.ts, 15, 74)) ->Point : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) +>origin : Symbol(Point.origin, Decl(sourceMap-FileWithComments.ts, 14, 74)) +>Point : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) } // Variable comment after class var a = 10; ->a : Symbol(a, Decl(sourceMap-FileWithComments.ts, 22, 7)) +>a : Symbol(a, Decl(sourceMap-FileWithComments.ts, 21, 7)) export function foo() { ->foo : Symbol(foo, Decl(sourceMap-FileWithComments.ts, 22, 15)) +>foo : Symbol(foo, Decl(sourceMap-FileWithComments.ts, 21, 15)) } /** comment after function * this is another comment */ var b = 10; ->b : Symbol(b, Decl(sourceMap-FileWithComments.ts, 30, 7)) +>b : Symbol(b, Decl(sourceMap-FileWithComments.ts, 29, 7)) } /** Local Variable */ var p: IPoint = new Shapes.Point(3, 4); ->p : Symbol(p, Decl(sourceMap-FileWithComments.ts, 34, 3)) +>p : Symbol(p, Decl(sourceMap-FileWithComments.ts, 33, 3)) >IPoint : Symbol(IPoint, Decl(sourceMap-FileWithComments.ts, 0, 0)) ->Shapes.Point : Symbol(Shapes.Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) ->Shapes : Symbol(Shapes, Decl(sourceMap-FileWithComments.ts, 4, 1)) ->Point : Symbol(Shapes.Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) +>Shapes.Point : Symbol(Shapes.Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) +>Shapes : Symbol(Shapes, Decl(sourceMap-FileWithComments.ts, 3, 1)) +>Point : Symbol(Shapes.Point, Decl(sourceMap-FileWithComments.ts, 6, 15)) var dist = p.getDist(); ->dist : Symbol(dist, Decl(sourceMap-FileWithComments.ts, 35, 3)) ->p.getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 2, 18)) ->p : Symbol(p, Decl(sourceMap-FileWithComments.ts, 34, 3)) ->getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 2, 18)) +>dist : Symbol(dist, Decl(sourceMap-FileWithComments.ts, 34, 3)) +>p.getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 1, 18)) +>p : Symbol(p, Decl(sourceMap-FileWithComments.ts, 33, 3)) +>getDist : Symbol(IPoint.getDist, Decl(sourceMap-FileWithComments.ts, 1, 18)) diff --git a/tests/baselines/reference/sourceMap-FileWithComments.types b/tests/baselines/reference/sourceMap-FileWithComments.types index 2198fa9a59022..cfb6ececffd30 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.types +++ b/tests/baselines/reference/sourceMap-FileWithComments.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMap-FileWithComments.ts === - // Interface interface IPoint { >IPoint : IPoint diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js index 01d784be7f81e..699c1b68e281b 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js @@ -1,5 +1,4 @@ //// [sourceMap-InterfacePrecedingVariableDeclaration1.ts] - interface I {} var x = 0; diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js.map b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js.map index a83a47f887ac4..7b56fdcf290d3 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js.map +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.js.map @@ -1,2 +1,2 @@ //// [sourceMap-InterfacePrecedingVariableDeclaration1.js.map] -{"version":3,"file":"sourceMap-InterfacePrecedingVariableDeclaration1.js","sourceRoot":"","sources":["sourceMap-InterfacePrecedingVariableDeclaration1.ts"],"names":[],"mappings":"AAEA,IAAI,CAAC,GAAG,CAAC,CAAC"} \ No newline at end of file +{"version":3,"file":"sourceMap-InterfacePrecedingVariableDeclaration1.js","sourceRoot":"","sources":["sourceMap-InterfacePrecedingVariableDeclaration1.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,CAAC,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.sourcemap.txt b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.sourcemap.txt index f409fa206eaf6..6a67f65b56137 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.sourcemap.txt +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.sourcemap.txt @@ -16,19 +16,18 @@ sourceFile:sourceMap-InterfacePrecedingVariableDeclaration1.ts 5 > ^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >interface I {} +1 >interface I {} > 2 >var 3 > x 4 > = 5 > 0 6 > ; -1 >Emitted(1, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(3, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(3, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(3, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(3, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMap-InterfacePrecedingVariableDeclaration1.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.symbols b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.symbols index 7de2b91464d7f..bb94e55cda2e7 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.symbols +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/sourceMap-InterfacePrecedingVariableDeclaration1.ts === - interface I {} >I : Symbol(I, Decl(sourceMap-InterfacePrecedingVariableDeclaration1.ts, 0, 0)) var x = 0; ->x : Symbol(x, Decl(sourceMap-InterfacePrecedingVariableDeclaration1.ts, 2, 3)) +>x : Symbol(x, Decl(sourceMap-InterfacePrecedingVariableDeclaration1.ts, 1, 3)) diff --git a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.types b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.types index 5faca1a4ddb6b..7bf55220d28ed 100644 --- a/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.types +++ b/tests/baselines/reference/sourceMap-InterfacePrecedingVariableDeclaration1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMap-InterfacePrecedingVariableDeclaration1.ts === - interface I {} >I : I diff --git a/tests/baselines/reference/sourceMap-NewLine1.js b/tests/baselines/reference/sourceMap-NewLine1.js index 7f2bb6cd314cc..47801427eec32 100644 --- a/tests/baselines/reference/sourceMap-NewLine1.js +++ b/tests/baselines/reference/sourceMap-NewLine1.js @@ -1,5 +1,4 @@ //// [sourceMap-NewLine1.ts] - //// [sourceMap-NewLine1.js] diff --git a/tests/baselines/reference/sourceMap-NewLine1.symbols b/tests/baselines/reference/sourceMap-NewLine1.symbols index a9097264f4e5d..4473db86e82ee 100644 --- a/tests/baselines/reference/sourceMap-NewLine1.symbols +++ b/tests/baselines/reference/sourceMap-NewLine1.symbols @@ -1,4 +1,3 @@ === tests/cases/compiler/sourceMap-NewLine1.ts === -No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-NewLine1.types b/tests/baselines/reference/sourceMap-NewLine1.types index a9097264f4e5d..4473db86e82ee 100644 --- a/tests/baselines/reference/sourceMap-NewLine1.types +++ b/tests/baselines/reference/sourceMap-NewLine1.types @@ -1,4 +1,3 @@ === tests/cases/compiler/sourceMap-NewLine1.ts === -No type information for this code. No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js index 8745facb3a628..3404a5ee04c15 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js @@ -1,5 +1,4 @@ //// [sourceMap-StringLiteralWithNewLine.ts] - interface Document { } interface Window { diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js.map b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js.map index c86a8937ed79e..003b442399eb9 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js.map +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.js.map @@ -1,2 +1,2 @@ //// [sourceMap-StringLiteralWithNewLine.js.map] -{"version":3,"file":"sourceMap-StringLiteralWithNewLine.js","sourceRoot":"","sources":["sourceMap-StringLiteralWithNewLine.ts"],"names":[],"mappings":"AAQA,IAAO,GAAG,CAKT;AALD,WAAO,GAAG;IACN,IAAI,CAAC,GAAG,OAAO,CAAC;IAChB,IAAI,CAAC,GAAG;wBACY,CAAC;IACrB,IAAI,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC;AAC5B,CAAC,EALM,GAAG,KAAH,GAAG,QAKT"} \ No newline at end of file +{"version":3,"file":"sourceMap-StringLiteralWithNewLine.js","sourceRoot":"","sources":["sourceMap-StringLiteralWithNewLine.ts"],"names":[],"mappings":"AAOA,IAAO,GAAG,CAKT;AALD,WAAO,GAAG;IACN,IAAI,CAAC,GAAG,OAAO,CAAC;IAChB,IAAI,CAAC,GAAG;wBACY,CAAC;IACrB,IAAI,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC;AAC5B,CAAC,EALM,GAAG,KAAH,GAAG,QAKT"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.sourcemap.txt b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.sourcemap.txt index f4c60842ea9a8..f7f0607ba0102 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.sourcemap.txt +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.sourcemap.txt @@ -14,8 +14,7 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 3 > ^^^ 4 > ^ 5 > ^^^^^^^^^^-> -1 > - >interface Document { +1 >interface Document { >} >interface Window { > document: Document; @@ -31,10 +30,10 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts > isn't this a lot of fun"; > var z = window.document; > } -1 >Emitted(1, 1) Source(9, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(9, 8) + SourceIndex(0) -3 >Emitted(1, 8) Source(9, 11) + SourceIndex(0) -4 >Emitted(1, 9) Source(14, 2) + SourceIndex(0) +1 >Emitted(1, 1) Source(8, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(8, 8) + SourceIndex(0) +3 >Emitted(1, 8) Source(8, 11) + SourceIndex(0) +4 >Emitted(1, 9) Source(13, 2) + SourceIndex(0) --- >>>(function (Foo) { 1-> @@ -44,9 +43,9 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 1-> 2 >module 3 > Foo -1->Emitted(2, 1) Source(9, 1) + SourceIndex(0) -2 >Emitted(2, 12) Source(9, 8) + SourceIndex(0) -3 >Emitted(2, 15) Source(9, 11) + SourceIndex(0) +1->Emitted(2, 1) Source(8, 1) + SourceIndex(0) +2 >Emitted(2, 12) Source(8, 8) + SourceIndex(0) +3 >Emitted(2, 15) Source(8, 11) + SourceIndex(0) --- >>> var x = "test1"; 1->^^^^ @@ -62,12 +61,12 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 4 > = 5 > "test1" 6 > ; -1->Emitted(3, 5) Source(10, 5) + SourceIndex(0) -2 >Emitted(3, 9) Source(10, 9) + SourceIndex(0) -3 >Emitted(3, 10) Source(10, 10) + SourceIndex(0) -4 >Emitted(3, 13) Source(10, 13) + SourceIndex(0) -5 >Emitted(3, 20) Source(10, 20) + SourceIndex(0) -6 >Emitted(3, 21) Source(10, 21) + SourceIndex(0) +1->Emitted(3, 5) Source(9, 5) + SourceIndex(0) +2 >Emitted(3, 9) Source(9, 9) + SourceIndex(0) +3 >Emitted(3, 10) Source(9, 10) + SourceIndex(0) +4 >Emitted(3, 13) Source(9, 13) + SourceIndex(0) +5 >Emitted(3, 20) Source(9, 20) + SourceIndex(0) +6 >Emitted(3, 21) Source(9, 21) + SourceIndex(0) --- >>> var y = "test 2\ 1 >^^^^ @@ -80,10 +79,10 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 2 > var 3 > y 4 > = -1 >Emitted(4, 5) Source(11, 5) + SourceIndex(0) -2 >Emitted(4, 9) Source(11, 9) + SourceIndex(0) -3 >Emitted(4, 10) Source(11, 10) + SourceIndex(0) -4 >Emitted(4, 13) Source(11, 13) + SourceIndex(0) +1 >Emitted(4, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(4, 9) Source(10, 9) + SourceIndex(0) +3 >Emitted(4, 10) Source(10, 10) + SourceIndex(0) +4 >Emitted(4, 13) Source(10, 13) + SourceIndex(0) --- >>>isn't this a lot of fun"; 1->^^^^^^^^^^^^^^^^^^^^^^^^ @@ -92,8 +91,8 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 1->"test 2\ >isn't this a lot of fun" 2 > ; -1->Emitted(5, 25) Source(12, 25) + SourceIndex(0) -2 >Emitted(5, 26) Source(12, 26) + SourceIndex(0) +1->Emitted(5, 25) Source(11, 25) + SourceIndex(0) +2 >Emitted(5, 26) Source(11, 26) + SourceIndex(0) --- >>> var z = window.document; 1->^^^^ @@ -113,14 +112,14 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts 6 > . 7 > document 8 > ; -1->Emitted(6, 5) Source(13, 5) + SourceIndex(0) -2 >Emitted(6, 9) Source(13, 9) + SourceIndex(0) -3 >Emitted(6, 10) Source(13, 10) + SourceIndex(0) -4 >Emitted(6, 13) Source(13, 13) + SourceIndex(0) -5 >Emitted(6, 19) Source(13, 19) + SourceIndex(0) -6 >Emitted(6, 20) Source(13, 20) + SourceIndex(0) -7 >Emitted(6, 28) Source(13, 28) + SourceIndex(0) -8 >Emitted(6, 29) Source(13, 29) + SourceIndex(0) +1->Emitted(6, 5) Source(12, 5) + SourceIndex(0) +2 >Emitted(6, 9) Source(12, 9) + SourceIndex(0) +3 >Emitted(6, 10) Source(12, 10) + SourceIndex(0) +4 >Emitted(6, 13) Source(12, 13) + SourceIndex(0) +5 >Emitted(6, 19) Source(12, 19) + SourceIndex(0) +6 >Emitted(6, 20) Source(12, 20) + SourceIndex(0) +7 >Emitted(6, 28) Source(12, 28) + SourceIndex(0) +8 >Emitted(6, 29) Source(12, 29) + SourceIndex(0) --- >>>})(Foo || (Foo = {})); 1 > @@ -144,12 +143,12 @@ sourceFile:sourceMap-StringLiteralWithNewLine.ts > isn't this a lot of fun"; > var z = window.document; > } -1 >Emitted(7, 1) Source(14, 1) + SourceIndex(0) -2 >Emitted(7, 2) Source(14, 2) + SourceIndex(0) -3 >Emitted(7, 4) Source(9, 8) + SourceIndex(0) -4 >Emitted(7, 7) Source(9, 11) + SourceIndex(0) -5 >Emitted(7, 12) Source(9, 8) + SourceIndex(0) -6 >Emitted(7, 15) Source(9, 11) + SourceIndex(0) -7 >Emitted(7, 23) Source(14, 2) + SourceIndex(0) +1 >Emitted(7, 1) Source(13, 1) + SourceIndex(0) +2 >Emitted(7, 2) Source(13, 2) + SourceIndex(0) +3 >Emitted(7, 4) Source(8, 8) + SourceIndex(0) +4 >Emitted(7, 7) Source(8, 11) + SourceIndex(0) +5 >Emitted(7, 12) Source(8, 8) + SourceIndex(0) +6 >Emitted(7, 15) Source(8, 11) + SourceIndex(0) +7 >Emitted(7, 23) Source(13, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMap-StringLiteralWithNewLine.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.symbols b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.symbols index 3b1d95afc001f..d6038b946ef24 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.symbols +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.symbols @@ -1,32 +1,31 @@ === tests/cases/compiler/sourceMap-StringLiteralWithNewLine.ts === - interface Document { >Document : Symbol(Document, Decl(sourceMap-StringLiteralWithNewLine.ts, 0, 0)) } interface Window { ->Window : Symbol(Window, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 1)) +>Window : Symbol(Window, Decl(sourceMap-StringLiteralWithNewLine.ts, 1, 1)) document: Document; ->document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 3, 18)) +>document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 18)) >Document : Symbol(Document, Decl(sourceMap-StringLiteralWithNewLine.ts, 0, 0)) } declare var window: Window; ->window : Symbol(window, Decl(sourceMap-StringLiteralWithNewLine.ts, 6, 11)) ->Window : Symbol(Window, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 1)) +>window : Symbol(window, Decl(sourceMap-StringLiteralWithNewLine.ts, 5, 11)) +>Window : Symbol(Window, Decl(sourceMap-StringLiteralWithNewLine.ts, 1, 1)) module Foo { ->Foo : Symbol(Foo, Decl(sourceMap-StringLiteralWithNewLine.ts, 6, 27)) +>Foo : Symbol(Foo, Decl(sourceMap-StringLiteralWithNewLine.ts, 5, 27)) var x = "test1"; ->x : Symbol(x, Decl(sourceMap-StringLiteralWithNewLine.ts, 9, 7)) +>x : Symbol(x, Decl(sourceMap-StringLiteralWithNewLine.ts, 8, 7)) var y = "test 2\ ->y : Symbol(y, Decl(sourceMap-StringLiteralWithNewLine.ts, 10, 7)) +>y : Symbol(y, Decl(sourceMap-StringLiteralWithNewLine.ts, 9, 7)) isn't this a lot of fun"; var z = window.document; ->z : Symbol(z, Decl(sourceMap-StringLiteralWithNewLine.ts, 12, 7)) ->window.document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 3, 18)) ->window : Symbol(window, Decl(sourceMap-StringLiteralWithNewLine.ts, 6, 11)) ->document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 3, 18)) +>z : Symbol(z, Decl(sourceMap-StringLiteralWithNewLine.ts, 11, 7)) +>window.document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 18)) +>window : Symbol(window, Decl(sourceMap-StringLiteralWithNewLine.ts, 5, 11)) +>document : Symbol(Window.document, Decl(sourceMap-StringLiteralWithNewLine.ts, 2, 18)) } diff --git a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.types b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.types index 26bfd605b9529..9a7e416b90718 100644 --- a/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.types +++ b/tests/baselines/reference/sourceMap-StringLiteralWithNewLine.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMap-StringLiteralWithNewLine.ts === - interface Document { >Document : Document } diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js index d4c419278c7e6..3db1230db06c1 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts] - var [x] = [1, 2]; //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map index faa5e070b0a54..191d39ee6d31c 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts"],"names":[],"mappings":"AACK,IAAA,aAAC,CAAW"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts"],"names":[],"mappings":"AAAK,IAAA,aAAC,CAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.sourcemap.txt index 0499d382d10e1..1f721ceb2bea8 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.sourcemap.txt @@ -14,14 +14,13 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern4 3 > ^^^^^^^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var [ +1 >var [ 2 > 3 > x 4 > ] = [1, 2]; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 18) Source(2, 7) + SourceIndex(0) -4 >Emitted(1, 19) Source(2, 18) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 18) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 19) Source(1, 18) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.symbols index 4695a8cd598c5..560f3b4c9fd3e 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts === - var [x] = [1, 2]; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts, 1, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts, 0, 5)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.types index 4f61c672b818b..052cb7777a18a 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern4.ts === - var [x] = [1, 2]; >x : number >[1, 2] : [number, number] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js index 10df853c22068..df45d144071b9 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts] - var [x] = [1, 2]; var [y, z] = [1, 2]; diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map index 31ad84b4b4440..456a64e7f34c2 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts"],"names":[],"mappings":"AACK,IAAA,aAAC,CAAW;AACb,IAAA,WAAe,EAAd,SAAC,EAAE,SAAC,CAAW"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts"],"names":[],"mappings":"AAAK,IAAA,aAAC,CAAW;AACb,IAAA,WAAe,EAAd,SAAC,EAAE,SAAC,CAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.sourcemap.txt index 1775f60ffe030..2603b53c456fa 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.sourcemap.txt @@ -14,15 +14,14 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern5 3 > ^^^^^^^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var [ +1 >var [ 2 > 3 > x 4 > ] = [1, 2]; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 18) Source(2, 7) + SourceIndex(0) -4 >Emitted(1, 19) Source(2, 18) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 18) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 19) Source(1, 18) + SourceIndex(0) --- >>>var _a = [1, 2], y = _a[0], z = _a[1]; 1-> @@ -43,13 +42,13 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern5 6 > , 7 > z 8 > ] = [1, 2]; -1->Emitted(2, 1) Source(3, 5) + SourceIndex(0) -2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(2, 16) Source(3, 20) + SourceIndex(0) -4 >Emitted(2, 18) Source(3, 6) + SourceIndex(0) -5 >Emitted(2, 27) Source(3, 7) + SourceIndex(0) -6 >Emitted(2, 29) Source(3, 9) + SourceIndex(0) -7 >Emitted(2, 38) Source(3, 10) + SourceIndex(0) -8 >Emitted(2, 39) Source(3, 21) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 5) + SourceIndex(0) +2 >Emitted(2, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(2, 16) Source(2, 20) + SourceIndex(0) +4 >Emitted(2, 18) Source(2, 6) + SourceIndex(0) +5 >Emitted(2, 27) Source(2, 7) + SourceIndex(0) +6 >Emitted(2, 29) Source(2, 9) + SourceIndex(0) +7 >Emitted(2, 38) Source(2, 10) + SourceIndex(0) +8 >Emitted(2, 39) Source(2, 21) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.symbols index 5954329077267..ad0be4d90b3da 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts === - var [x] = [1, 2]; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 1, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 0, 5)) var [y, z] = [1, 2]; ->y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 2, 5)) ->z : Symbol(z, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 2, 7)) +>y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 1, 5)) +>z : Symbol(z, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts, 1, 7)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.types index 908e566ca7135..3061ce7e9d38e 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern5.ts === - var [x] = [1, 2]; >x : number >[1, 2] : [number, number] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js index d4baadb6562ed..02efbda7b1894 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts] - var [x = 20] = [1, 2]; //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map index 1271129d1c987..309dc1595abf8 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts"],"names":[],"mappings":"AACK,IAAA,cAAM,EAAN,2BAAM,CAAW"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts"],"names":[],"mappings":"AAAK,IAAA,cAAM,EAAN,2BAAM,CAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.sourcemap.txt index 2dadb2f535254..8f971d65cd7dd 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.sourcemap.txt @@ -16,18 +16,17 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern6 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var [ +1 >var [ 2 > 3 > x = 20 4 > 5 > x = 20 6 > ] = [1, 2]; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 19) Source(2, 12) + SourceIndex(0) -4 >Emitted(1, 21) Source(2, 6) + SourceIndex(0) -5 >Emitted(1, 48) Source(2, 12) + SourceIndex(0) -6 >Emitted(1, 49) Source(2, 23) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 19) Source(1, 12) + SourceIndex(0) +4 >Emitted(1, 21) Source(1, 6) + SourceIndex(0) +5 >Emitted(1, 48) Source(1, 12) + SourceIndex(0) +6 >Emitted(1, 49) Source(1, 23) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.symbols index 6c368f4996e4f..4a478cdeee780 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts === - var [x = 20] = [1, 2]; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts, 1, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts, 0, 5)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.types index 166a6192bb736..61b32753bf705 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern6.ts === - var [x = 20] = [1, 2]; >x : number >20 : 20 diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js index 73d2e85e9daa1..720004a3c114b 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts] - var [x = 20, j] = [1, 2]; //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map index eb0df6f9ca294..94422f7614540 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts"],"names":[],"mappings":"AACI,IAAA,WAAoB,EAAnB,UAAM,EAAN,2BAAM,EAAE,SAAC,CAAW"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts"],"names":[],"mappings":"AAAI,IAAA,WAAoB,EAAnB,UAAM,EAAN,2BAAM,EAAE,SAAC,CAAW"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.sourcemap.txt index e4b2c871cb1da..2a088a1dc8287 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.sourcemap.txt @@ -20,8 +20,7 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern7 9 > ^^^^^^^^^ 10> ^ 11> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var +1 >var 2 > 3 > [x = 20, j] = [1, 2] 4 > @@ -31,15 +30,15 @@ sourceFile:sourceMapValidationDestructuringVariableStatementArrayBindingPattern7 8 > , 9 > j 10> ] = [1, 2]; -1 >Emitted(1, 1) Source(2, 5) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 16) Source(2, 25) + SourceIndex(0) -4 >Emitted(1, 18) Source(2, 6) + SourceIndex(0) -5 >Emitted(1, 28) Source(2, 12) + SourceIndex(0) -6 >Emitted(1, 30) Source(2, 6) + SourceIndex(0) -7 >Emitted(1, 57) Source(2, 12) + SourceIndex(0) -8 >Emitted(1, 59) Source(2, 14) + SourceIndex(0) -9 >Emitted(1, 68) Source(2, 15) + SourceIndex(0) -10>Emitted(1, 69) Source(2, 26) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 5) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 16) Source(1, 25) + SourceIndex(0) +4 >Emitted(1, 18) Source(1, 6) + SourceIndex(0) +5 >Emitted(1, 28) Source(1, 12) + SourceIndex(0) +6 >Emitted(1, 30) Source(1, 6) + SourceIndex(0) +7 >Emitted(1, 57) Source(1, 12) + SourceIndex(0) +8 >Emitted(1, 59) Source(1, 14) + SourceIndex(0) +9 >Emitted(1, 68) Source(1, 15) + SourceIndex(0) +10>Emitted(1, 69) Source(1, 26) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.symbols index 4f57dffff26d1..83e9720481622 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts === - var [x = 20, j] = [1, 2]; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts, 1, 5)) ->j : Symbol(j, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts, 1, 12)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts, 0, 5)) +>j : Symbol(j, Decl(sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts, 0, 12)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.types index da537c6e10958..6b6e6c2c7221f 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern7.ts === - var [x = 20, j] = [1, 2]; >x : number >20 : 20 diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js index 8259981857ce0..a20e7578d9312 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts] - var {x} = { x: 20 }; //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map index 71a3949b55350..b0a552391c9c8 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts"],"names":[],"mappings":"AACK,IAAA,eAAC,CAAc"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts"],"names":[],"mappings":"AAAK,IAAA,eAAC,CAAc"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.sourcemap.txt index 829e0d1919569..0c554c986a4b6 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.sourcemap.txt @@ -14,14 +14,13 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 3 > ^^^^^^^^^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var { +1 >var { 2 > 3 > x 4 > } = { x: 20 }; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 20) Source(2, 7) + SourceIndex(0) -4 >Emitted(1, 21) Source(2, 21) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 20) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 21) Source(1, 21) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.symbols index 950fca4eb00a4..a0c5682074d9e 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts === - var {x} = { x: 20 }; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts, 1, 5)) ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts, 1, 11)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts, 0, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts, 0, 11)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.types index 14995bbe1c9bc..b80df17fe673b 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern1.ts === - var {x} = { x: 20 }; >x : number >{ x: 20 } : { x: number; } diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js index d4d52e5e8d9d1..44295762d6d9b 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts] - var {x} = { x: 20 }; var { a, b } = { a: 30, b: 40 }; diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map index 7eda5a24bdb6f..eb36a3b9022d0 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts"],"names":[],"mappings":"AACK,IAAA,eAAC,CAAc;AAChB,IAAA,qBAA2B,EAAzB,QAAC,EAAE,QAAC,CAAsB"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts"],"names":[],"mappings":"AAAK,IAAA,eAAC,CAAc;AAChB,IAAA,qBAA2B,EAAzB,QAAC,EAAE,QAAC,CAAsB"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.sourcemap.txt index 380c6e2b14e61..2390f91a8b126 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.sourcemap.txt @@ -14,15 +14,14 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 3 > ^^^^^^^^^^^^^^^ 4 > ^ 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var { +1 >var { 2 > 3 > x 4 > } = { x: 20 }; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 20) Source(2, 7) + SourceIndex(0) -4 >Emitted(1, 21) Source(2, 21) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 20) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 21) Source(1, 21) + SourceIndex(0) --- >>>var _a = { a: 30, b: 40 }, a = _a.a, b = _a.b; 1-> @@ -43,13 +42,13 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 6 > , 7 > b 8 > } = { a: 30, b: 40 }; -1->Emitted(2, 1) Source(3, 5) + SourceIndex(0) -2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(2, 26) Source(3, 32) + SourceIndex(0) -4 >Emitted(2, 28) Source(3, 7) + SourceIndex(0) -5 >Emitted(2, 36) Source(3, 8) + SourceIndex(0) -6 >Emitted(2, 38) Source(3, 10) + SourceIndex(0) -7 >Emitted(2, 46) Source(3, 11) + SourceIndex(0) -8 >Emitted(2, 47) Source(3, 33) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 5) + SourceIndex(0) +2 >Emitted(2, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(2, 26) Source(2, 32) + SourceIndex(0) +4 >Emitted(2, 28) Source(2, 7) + SourceIndex(0) +5 >Emitted(2, 36) Source(2, 8) + SourceIndex(0) +6 >Emitted(2, 38) Source(2, 10) + SourceIndex(0) +7 >Emitted(2, 46) Source(2, 11) + SourceIndex(0) +8 >Emitted(2, 47) Source(2, 33) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.symbols index 4fa80ecf05e40..6282df94ccf93 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts === - var {x} = { x: 20 }; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 5)) ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 11)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 0, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 0, 11)) var { a, b } = { a: 30, b: 40 }; ->a : Symbol(a, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 2, 5)) ->b : Symbol(b, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 2, 8)) ->a : Symbol(a, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 2, 16)) ->b : Symbol(b, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 2, 23)) +>a : Symbol(a, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 5)) +>b : Symbol(b, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 8)) +>a : Symbol(a, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 16)) +>b : Symbol(b, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts, 1, 23)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.types index 52a5484052c18..f83ac86a73645 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern2.ts === - var {x} = { x: 20 }; >x : number >{ x: 20 } : { x: number; } diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js index f146e4bb8a79c..88a5bce4dccd7 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts] - var {x = 500} = { x: 20 }; //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map index 3bc06d2dc75fc..1faa8f8e71a2c 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts"],"names":[],"mappings":"AACK,IAAA,gBAAO,EAAP,4BAAO,CAAc"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts"],"names":[],"mappings":"AAAK,IAAA,gBAAO,EAAP,4BAAO,CAAc"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.sourcemap.txt index fb3483829c659..d58e756de4227 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.sourcemap.txt @@ -16,18 +16,17 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - >var { +1 >var { 2 > 3 > x = 500 4 > 5 > x = 500 6 > } = { x: 20 }; -1 >Emitted(1, 1) Source(2, 6) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 6) + SourceIndex(0) -3 >Emitted(1, 21) Source(2, 13) + SourceIndex(0) -4 >Emitted(1, 23) Source(2, 6) + SourceIndex(0) -5 >Emitted(1, 51) Source(2, 13) + SourceIndex(0) -6 >Emitted(1, 52) Source(2, 27) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 6) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 6) + SourceIndex(0) +3 >Emitted(1, 21) Source(1, 13) + SourceIndex(0) +4 >Emitted(1, 23) Source(1, 6) + SourceIndex(0) +5 >Emitted(1, 51) Source(1, 13) + SourceIndex(0) +6 >Emitted(1, 52) Source(1, 27) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.symbols index a668ab8e73393..15899184e199a 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts === - var {x = 500} = { x: 20 }; ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts, 1, 5)) ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts, 1, 17)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts, 0, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts, 0, 17)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.types index 4b70fa8aa8dcd..c4ad284f293b0 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern3.ts === - var {x = 500} = { x: 20 }; >x : number >500 : 500 diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js index d785d2dd1fd56..3b74d1b753576 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js @@ -1,5 +1,4 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts] - var {x = 500, y} = { x: 20, y: "hi" }; diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map index 5f160d2ac45c7..2b6cd16157df3 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map] -{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts"],"names":[],"mappings":"AACI,IAAA,uBACwB,EADvB,SAAO,EAAP,4BAAO,EACP,QAAC,CAAuB"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js","sourceRoot":"","sources":["sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts"],"names":[],"mappings":"AAAI,IAAA,uBACwB,EADvB,SAAO,EAAP,4BAAO,EACP,QAAC,CAAuB"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.sourcemap.txt index 6a64ae9c320be..68d24cb1b32bf 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.sourcemap.txt @@ -20,8 +20,7 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern 9 > ^^^^^^^^ 10> ^ 11> ^^^^^^^^^^^^^^^^^^-> -1 > - >var +1 >var 2 > 3 > {x = 500, > y} = { x: 20, y: "hi" } @@ -33,15 +32,15 @@ sourceFile:sourceMapValidationDestructuringVariableStatementObjectBindingPattern > 9 > y 10> } = { x: 20, y: "hi" }; -1 >Emitted(1, 1) Source(2, 5) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 28) Source(3, 29) + SourceIndex(0) -4 >Emitted(1, 30) Source(2, 6) + SourceIndex(0) -5 >Emitted(1, 39) Source(2, 13) + SourceIndex(0) -6 >Emitted(1, 41) Source(2, 6) + SourceIndex(0) -7 >Emitted(1, 69) Source(2, 13) + SourceIndex(0) -8 >Emitted(1, 71) Source(3, 6) + SourceIndex(0) -9 >Emitted(1, 79) Source(3, 7) + SourceIndex(0) -10>Emitted(1, 80) Source(3, 30) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 5) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 28) Source(2, 29) + SourceIndex(0) +4 >Emitted(1, 30) Source(1, 6) + SourceIndex(0) +5 >Emitted(1, 39) Source(1, 13) + SourceIndex(0) +6 >Emitted(1, 41) Source(1, 6) + SourceIndex(0) +7 >Emitted(1, 69) Source(1, 13) + SourceIndex(0) +8 >Emitted(1, 71) Source(2, 6) + SourceIndex(0) +9 >Emitted(1, 79) Source(2, 7) + SourceIndex(0) +10>Emitted(1, 80) Source(2, 30) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.symbols b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.symbols index 8404c342c0bf5..bce2734b093e9 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.symbols +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts === - var {x = 500, ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 1, 5)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 0, 5)) y} = { x: 20, y: "hi" }; ->y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 1, 13)) ->x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 2, 11)) ->y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 2, 18)) +>y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 0, 13)) +>x : Symbol(x, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 1, 11)) +>y : Symbol(y, Decl(sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts, 1, 18)) diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.types index 1bd508ef2e55e..3952961897d87 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationDestructuringVariableStatementObjectBindingPattern4.ts === - var {x = 500, >x : number >500 : 500 diff --git a/tests/baselines/reference/sourceMapValidationLabeled.js b/tests/baselines/reference/sourceMapValidationLabeled.js index 50669b870abb8..7aabc47ea4ea0 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.js +++ b/tests/baselines/reference/sourceMapValidationLabeled.js @@ -1,5 +1,4 @@ //// [sourceMapValidationLabeled.ts] - x: var b = 10; diff --git a/tests/baselines/reference/sourceMapValidationLabeled.js.map b/tests/baselines/reference/sourceMapValidationLabeled.js.map index 206ac95b9512f..d1219f9896ffb 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.js.map +++ b/tests/baselines/reference/sourceMapValidationLabeled.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationLabeled.js.map] -{"version":3,"file":"sourceMapValidationLabeled.js","sourceRoot":"","sources":["sourceMapValidationLabeled.ts"],"names":[],"mappings":"AACA,CAAC,EACD,IAAI,CAAC,GAAG,EAAE,CAAC"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationLabeled.js","sourceRoot":"","sources":["sourceMapValidationLabeled.ts"],"names":[],"mappings":"AAAA,CAAC,EACD,IAAI,CAAC,GAAG,EAAE,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt b/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt index 7cf1bf896ca00..007208c78f95c 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt @@ -18,8 +18,7 @@ sourceFile:sourceMapValidationLabeled.ts 7 > ^^ 8 > ^ 9 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >x 3 > : > @@ -28,13 +27,13 @@ sourceFile:sourceMapValidationLabeled.ts 6 > = 7 > 10 8 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 2) Source(2, 2) + SourceIndex(0) -3 >Emitted(1, 4) Source(3, 1) + SourceIndex(0) -4 >Emitted(1, 8) Source(3, 5) + SourceIndex(0) -5 >Emitted(1, 9) Source(3, 6) + SourceIndex(0) -6 >Emitted(1, 12) Source(3, 9) + SourceIndex(0) -7 >Emitted(1, 14) Source(3, 11) + SourceIndex(0) -8 >Emitted(1, 15) Source(3, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 2) Source(1, 2) + SourceIndex(0) +3 >Emitted(1, 4) Source(2, 1) + SourceIndex(0) +4 >Emitted(1, 8) Source(2, 5) + SourceIndex(0) +5 >Emitted(1, 9) Source(2, 6) + SourceIndex(0) +6 >Emitted(1, 12) Source(2, 9) + SourceIndex(0) +7 >Emitted(1, 14) Source(2, 11) + SourceIndex(0) +8 >Emitted(1, 15) Source(2, 12) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationLabeled.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationLabeled.symbols b/tests/baselines/reference/sourceMapValidationLabeled.symbols index bf9abc593b34c..2a3c4f5606c38 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.symbols +++ b/tests/baselines/reference/sourceMapValidationLabeled.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/sourceMapValidationLabeled.ts === - x: var b = 10; ->b : Symbol(b, Decl(sourceMapValidationLabeled.ts, 2, 3)) +>b : Symbol(b, Decl(sourceMapValidationLabeled.ts, 1, 3)) diff --git a/tests/baselines/reference/sourceMapValidationLabeled.types b/tests/baselines/reference/sourceMapValidationLabeled.types index 6756494a5c75c..a3685eedba1d4 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.types +++ b/tests/baselines/reference/sourceMapValidationLabeled.types @@ -1,5 +1,4 @@ === tests/cases/compiler/sourceMapValidationLabeled.ts === - x: >x : any diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.js b/tests/baselines/reference/specializationsShouldNotAffectEachOther.js index 3116571166f58..06370fbd450ec 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.js +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.js @@ -1,5 +1,4 @@ //// [specializationsShouldNotAffectEachOther.ts] - interface Series { data: string[]; } diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols index 8c8b372bbc869..febbd451db7b4 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols @@ -1,44 +1,43 @@ === tests/cases/compiler/specializationsShouldNotAffectEachOther.ts === - interface Series { >Series : Symbol(Series, Decl(specializationsShouldNotAffectEachOther.ts, 0, 0)) data: string[]; ->data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19)) +>data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 0, 19)) } var series: Series; ->series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 5, 3)) +>series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 4, 3)) >Series : Symbol(Series, Decl(specializationsShouldNotAffectEachOther.ts, 0, 0)) function foo() { ->foo : Symbol(foo, Decl(specializationsShouldNotAffectEachOther.ts, 5, 19)) +>foo : Symbol(foo, Decl(specializationsShouldNotAffectEachOther.ts, 4, 19)) var seriesExtent = (series) => null; ->seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 10, 7)) ->series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 10, 24)) +>seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 9, 7)) +>series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 9, 24)) var series2: number[]; ->series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7)) +>series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 11, 7)) series2.map(seriesExtent); >series2.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7)) +>series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 11, 7)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 10, 7)) +>seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 9, 7)) return null; } var keyExtent2: any[] = series.data.map(function (d: string) { return d; }); ->keyExtent2 : Symbol(keyExtent2, Decl(specializationsShouldNotAffectEachOther.ts, 19, 3)) +>keyExtent2 : Symbol(keyExtent2, Decl(specializationsShouldNotAffectEachOther.ts, 18, 3)) >series.data.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->series.data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19)) ->series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 5, 3)) ->data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19)) +>series.data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 0, 19)) +>series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 4, 3)) +>data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 0, 19)) >map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50)) ->d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50)) +>d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 18, 50)) +>d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 18, 50)) diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types index d9c9b7baa20a6..01bdfc4bda690 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types @@ -1,5 +1,4 @@ === tests/cases/compiler/specializationsShouldNotAffectEachOther.ts === - interface Series { >Series : Series diff --git a/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.errors.txt b/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.errors.txt index 73318e782a311..0e9454b9018d1 100644 --- a/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.errors.txt +++ b/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.ts(2,10): error TS2394: Overload signature is not compatible with function implementation. +tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.ts(1,10): error TS2394: Overload signature is not compatible with function implementation. ==== tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.ts (1 errors) ==== - function foo(x: 'a'); ~~~ !!! error TS2394: Overload signature is not compatible with function implementation. diff --git a/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.js b/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.js index bb2dab559576b..2654049a323e2 100644 --- a/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.js +++ b/tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.js @@ -1,5 +1,4 @@ //// [specializedSignatureIsNotSubtypeOfNonSpecializedSignature.ts] - function foo(x: 'a'); function foo(x: number) { } diff --git a/tests/baselines/reference/spreadUnion2.js b/tests/baselines/reference/spreadUnion2.js index 6c7527af9dd26..b98046463c3a5 100644 --- a/tests/baselines/reference/spreadUnion2.js +++ b/tests/baselines/reference/spreadUnion2.js @@ -1,5 +1,4 @@ //// [spreadUnion2.ts] - declare const undefinedUnion: { a: number } | undefined; declare const nullUnion: { b: number } | null; declare const nullAndUndefinedUnion: null | undefined; diff --git a/tests/baselines/reference/spreadUnion2.symbols b/tests/baselines/reference/spreadUnion2.symbols index cc2c194f2a65f..05703fc32bde2 100644 --- a/tests/baselines/reference/spreadUnion2.symbols +++ b/tests/baselines/reference/spreadUnion2.symbols @@ -1,74 +1,73 @@ === tests/cases/compiler/spreadUnion2.ts === - declare const undefinedUnion: { a: number } | undefined; ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) ->a : Symbol(a, Decl(spreadUnion2.ts, 1, 31)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) +>a : Symbol(a, Decl(spreadUnion2.ts, 0, 31)) declare const nullUnion: { b: number } | null; ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) ->b : Symbol(b, Decl(spreadUnion2.ts, 2, 26)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) +>b : Symbol(b, Decl(spreadUnion2.ts, 1, 26)) declare const nullAndUndefinedUnion: null | undefined; ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 3, 13)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 2, 13)) var o1: { a: number }; ->o1 : Symbol(o1, Decl(spreadUnion2.ts, 5, 3), Decl(spreadUnion2.ts, 6, 3)) ->a : Symbol(a, Decl(spreadUnion2.ts, 5, 9)) +>o1 : Symbol(o1, Decl(spreadUnion2.ts, 4, 3), Decl(spreadUnion2.ts, 5, 3)) +>a : Symbol(a, Decl(spreadUnion2.ts, 4, 9)) var o1 = { ...undefinedUnion }; ->o1 : Symbol(o1, Decl(spreadUnion2.ts, 5, 3), Decl(spreadUnion2.ts, 6, 3)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) +>o1 : Symbol(o1, Decl(spreadUnion2.ts, 4, 3), Decl(spreadUnion2.ts, 5, 3)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) var o2: { b: number }; ->o2 : Symbol(o2, Decl(spreadUnion2.ts, 8, 3), Decl(spreadUnion2.ts, 9, 3)) ->b : Symbol(b, Decl(spreadUnion2.ts, 8, 9)) +>o2 : Symbol(o2, Decl(spreadUnion2.ts, 7, 3), Decl(spreadUnion2.ts, 8, 3)) +>b : Symbol(b, Decl(spreadUnion2.ts, 7, 9)) var o2 = { ...nullUnion }; ->o2 : Symbol(o2, Decl(spreadUnion2.ts, 8, 3), Decl(spreadUnion2.ts, 9, 3)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) +>o2 : Symbol(o2, Decl(spreadUnion2.ts, 7, 3), Decl(spreadUnion2.ts, 8, 3)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) var o3: { a: number, b: number }; ->o3 : Symbol(o3, Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3), Decl(spreadUnion2.ts, 13, 3)) ->a : Symbol(a, Decl(spreadUnion2.ts, 11, 9)) ->b : Symbol(b, Decl(spreadUnion2.ts, 11, 20)) +>o3 : Symbol(o3, Decl(spreadUnion2.ts, 10, 3), Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3)) +>a : Symbol(a, Decl(spreadUnion2.ts, 10, 9)) +>b : Symbol(b, Decl(spreadUnion2.ts, 10, 20)) var o3 = { ...undefinedUnion, ...nullUnion }; ->o3 : Symbol(o3, Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3), Decl(spreadUnion2.ts, 13, 3)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) +>o3 : Symbol(o3, Decl(spreadUnion2.ts, 10, 3), Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) var o3 = { ...nullUnion, ...undefinedUnion }; ->o3 : Symbol(o3, Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3), Decl(spreadUnion2.ts, 13, 3)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) +>o3 : Symbol(o3, Decl(spreadUnion2.ts, 10, 3), Decl(spreadUnion2.ts, 11, 3), Decl(spreadUnion2.ts, 12, 3)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) var o4: { a: number }; ->o4 : Symbol(o4, Decl(spreadUnion2.ts, 15, 3), Decl(spreadUnion2.ts, 16, 3)) ->a : Symbol(a, Decl(spreadUnion2.ts, 15, 9)) +>o4 : Symbol(o4, Decl(spreadUnion2.ts, 14, 3), Decl(spreadUnion2.ts, 15, 3)) +>a : Symbol(a, Decl(spreadUnion2.ts, 14, 9)) var o4 = { ...undefinedUnion, ...undefinedUnion }; ->o4 : Symbol(o4, Decl(spreadUnion2.ts, 15, 3), Decl(spreadUnion2.ts, 16, 3)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) ->undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 1, 13)) +>o4 : Symbol(o4, Decl(spreadUnion2.ts, 14, 3), Decl(spreadUnion2.ts, 15, 3)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) +>undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13)) var o5: { b: number }; ->o5 : Symbol(o5, Decl(spreadUnion2.ts, 18, 3), Decl(spreadUnion2.ts, 19, 3)) ->b : Symbol(b, Decl(spreadUnion2.ts, 18, 9)) +>o5 : Symbol(o5, Decl(spreadUnion2.ts, 17, 3), Decl(spreadUnion2.ts, 18, 3)) +>b : Symbol(b, Decl(spreadUnion2.ts, 17, 9)) var o5 = { ...nullUnion, ...nullUnion }; ->o5 : Symbol(o5, Decl(spreadUnion2.ts, 18, 3), Decl(spreadUnion2.ts, 19, 3)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) ->nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 2, 13)) +>o5 : Symbol(o5, Decl(spreadUnion2.ts, 17, 3), Decl(spreadUnion2.ts, 18, 3)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) +>nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13)) var o6: { }; ->o6 : Symbol(o6, Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3), Decl(spreadUnion2.ts, 23, 3)) +>o6 : Symbol(o6, Decl(spreadUnion2.ts, 20, 3), Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3)) var o6 = { ...nullAndUndefinedUnion, ...nullAndUndefinedUnion }; ->o6 : Symbol(o6, Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3), Decl(spreadUnion2.ts, 23, 3)) ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 3, 13)) ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 3, 13)) +>o6 : Symbol(o6, Decl(spreadUnion2.ts, 20, 3), Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 2, 13)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 2, 13)) var o6 = { ...nullAndUndefinedUnion }; ->o6 : Symbol(o6, Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3), Decl(spreadUnion2.ts, 23, 3)) ->nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 3, 13)) +>o6 : Symbol(o6, Decl(spreadUnion2.ts, 20, 3), Decl(spreadUnion2.ts, 21, 3), Decl(spreadUnion2.ts, 22, 3)) +>nullAndUndefinedUnion : Symbol(nullAndUndefinedUnion, Decl(spreadUnion2.ts, 2, 13)) diff --git a/tests/baselines/reference/spreadUnion2.types b/tests/baselines/reference/spreadUnion2.types index cf90381ca77f2..97fbb9838c7cc 100644 --- a/tests/baselines/reference/spreadUnion2.types +++ b/tests/baselines/reference/spreadUnion2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/spreadUnion2.ts === - declare const undefinedUnion: { a: number } | undefined; >undefinedUnion : { a: number; } | undefined >a : number diff --git a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols index 46297eab86a32..bafb805fb191d 100644 --- a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols +++ b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols @@ -1,107 +1,106 @@ === tests/cases/conformance/classes/propertyMemberDeclarations/decl.d.ts === - // name declare class StaticName { >StaticName : Symbol(StaticName, Decl(decl.d.ts, 0, 0)) static name: number; // ok ->name : Symbol(StaticName.name, Decl(decl.d.ts, 2, 26)) +>name : Symbol(StaticName.name, Decl(decl.d.ts, 1, 26)) name: string; // ok ->name : Symbol(StaticName.name, Decl(decl.d.ts, 3, 24)) +>name : Symbol(StaticName.name, Decl(decl.d.ts, 2, 24)) } declare class StaticNameFn { ->StaticNameFn : Symbol(StaticNameFn, Decl(decl.d.ts, 5, 1)) +>StaticNameFn : Symbol(StaticNameFn, Decl(decl.d.ts, 4, 1)) static name(): string; // ok ->name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 7, 28)) +>name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 6, 28)) name(): string; // ok ->name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 8, 26)) +>name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 7, 26)) } // length declare class StaticLength { ->StaticLength : Symbol(StaticLength, Decl(decl.d.ts, 10, 1)) +>StaticLength : Symbol(StaticLength, Decl(decl.d.ts, 9, 1)) static length: number; // ok ->length : Symbol(StaticLength.length, Decl(decl.d.ts, 13, 28)) +>length : Symbol(StaticLength.length, Decl(decl.d.ts, 12, 28)) length: string; // ok ->length : Symbol(StaticLength.length, Decl(decl.d.ts, 14, 26)) +>length : Symbol(StaticLength.length, Decl(decl.d.ts, 13, 26)) } declare class StaticLengthFn { ->StaticLengthFn : Symbol(StaticLengthFn, Decl(decl.d.ts, 16, 1)) +>StaticLengthFn : Symbol(StaticLengthFn, Decl(decl.d.ts, 15, 1)) static length(): number; // ok ->length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 18, 30)) +>length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 17, 30)) length(): number; // ok ->length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 19, 28)) +>length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 18, 28)) } // prototype declare class StaticPrototype { ->StaticPrototype : Symbol(StaticPrototype, Decl(decl.d.ts, 21, 1)) +>StaticPrototype : Symbol(StaticPrototype, Decl(decl.d.ts, 20, 1)) static prototype: number; // ok ->prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 24, 31)) +>prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 23, 31)) prototype: string; // ok ->prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 25, 29)) +>prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 24, 29)) } declare class StaticPrototypeFn { ->StaticPrototypeFn : Symbol(StaticPrototypeFn, Decl(decl.d.ts, 27, 1)) +>StaticPrototypeFn : Symbol(StaticPrototypeFn, Decl(decl.d.ts, 26, 1)) static prototype: any; // ok ->prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 29, 33)) +>prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 28, 33)) prototype(): any; // ok ->prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 30, 26)) +>prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 29, 26)) } // caller declare class StaticCaller { ->StaticCaller : Symbol(StaticCaller, Decl(decl.d.ts, 32, 1)) +>StaticCaller : Symbol(StaticCaller, Decl(decl.d.ts, 31, 1)) static caller: number; // ok ->caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 35, 28)) +>caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 34, 28)) caller: string; // ok ->caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 36, 26)) +>caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 35, 26)) } declare class StaticCallerFn { ->StaticCallerFn : Symbol(StaticCallerFn, Decl(decl.d.ts, 38, 1)) +>StaticCallerFn : Symbol(StaticCallerFn, Decl(decl.d.ts, 37, 1)) static caller(): any; // ok ->caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 40, 30)) +>caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 39, 30)) caller(): any; // ok ->caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 41, 25)) +>caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 40, 25)) } // arguments declare class StaticArguments { ->StaticArguments : Symbol(StaticArguments, Decl(decl.d.ts, 43, 1)) +>StaticArguments : Symbol(StaticArguments, Decl(decl.d.ts, 42, 1)) static arguments: number; // ok ->arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 46, 31)) +>arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 45, 31)) arguments: string; // ok ->arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 47, 29)) +>arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 46, 29)) } declare class StaticArgumentsFn { ->StaticArgumentsFn : Symbol(StaticArgumentsFn, Decl(decl.d.ts, 49, 1)) +>StaticArgumentsFn : Symbol(StaticArgumentsFn, Decl(decl.d.ts, 48, 1)) static arguments(): any; // ok ->arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 51, 33)) +>arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 50, 33)) arguments(): any; // ok ->arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 52, 28)) +>arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 51, 28)) } diff --git a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types index 233bd8a46fc62..31a5ea0fc3cb4 100644 --- a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types +++ b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types @@ -1,5 +1,4 @@ === tests/cases/conformance/classes/propertyMemberDeclarations/decl.d.ts === - // name declare class StaticName { >StaticName : StaticName diff --git a/tests/baselines/reference/staticVisibility.errors.txt b/tests/baselines/reference/staticVisibility.errors.txt index a92cb7f88cda6..43691d2744f0e 100644 --- a/tests/baselines/reference/staticVisibility.errors.txt +++ b/tests/baselines/reference/staticVisibility.errors.txt @@ -1,14 +1,13 @@ -tests/cases/compiler/staticVisibility.ts(10,9): error TS2662: Cannot find name 's'. Did you mean the static member 'C1.s'? -tests/cases/compiler/staticVisibility.ts(13,9): error TS2662: Cannot find name 'b'. Did you mean the static member 'C1.b'? -tests/cases/compiler/staticVisibility.ts(18,9): error TS2304: Cannot find name 'v'. -tests/cases/compiler/staticVisibility.ts(19,14): error TS2339: Property 'p' does not exist on type 'typeof C1'. -tests/cases/compiler/staticVisibility.ts(31,12): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/staticVisibility.ts(33,12): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/staticVisibility.ts(33,29): error TS2304: Cannot find name 'barback'. +tests/cases/compiler/staticVisibility.ts(9,9): error TS2662: Cannot find name 's'. Did you mean the static member 'C1.s'? +tests/cases/compiler/staticVisibility.ts(12,9): error TS2662: Cannot find name 'b'. Did you mean the static member 'C1.b'? +tests/cases/compiler/staticVisibility.ts(17,9): error TS2304: Cannot find name 'v'. +tests/cases/compiler/staticVisibility.ts(18,14): error TS2339: Property 'p' does not exist on type 'typeof C1'. +tests/cases/compiler/staticVisibility.ts(30,12): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/staticVisibility.ts(32,12): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/staticVisibility.ts(32,29): error TS2304: Cannot find name 'barback'. ==== tests/cases/compiler/staticVisibility.ts (7 errors) ==== - class C1 { p: any; diff --git a/tests/baselines/reference/staticVisibility.js b/tests/baselines/reference/staticVisibility.js index fd0a3ba52b017..60047c9c050e4 100644 --- a/tests/baselines/reference/staticVisibility.js +++ b/tests/baselines/reference/staticVisibility.js @@ -1,5 +1,4 @@ //// [staticVisibility.ts] - class C1 { p: any; diff --git a/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.errors.txt b/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.errors.txt index 3405db573a984..bde4ec862bd35 100644 --- a/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.errors.txt +++ b/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts(3,8): error TS1214: Identifier expected. 'public' is a reserved word in strict mode. Modules are automatically in strict mode. -tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts(3,25): error TS2307: Cannot find module '1'. +tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts(2,8): error TS1214: Identifier expected. 'public' is a reserved word in strict mode. Modules are automatically in strict mode. +tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts(2,25): error TS2307: Cannot find module '1'. ==== tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts (2 errors) ==== - "use strict" import public = require("1"); ~~~~~~ diff --git a/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.js b/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.js index 409e6f675844a..16e8580e727cb 100644 --- a/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.js +++ b/tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.js @@ -1,5 +1,4 @@ //// [strictModeReservedWordInImportEqualDeclaration.ts] - "use strict" import public = require("1"); diff --git a/tests/baselines/reference/strictNullChecksNoWidening.js b/tests/baselines/reference/strictNullChecksNoWidening.js index ba26a04fc131a..72922d93f0247 100644 --- a/tests/baselines/reference/strictNullChecksNoWidening.js +++ b/tests/baselines/reference/strictNullChecksNoWidening.js @@ -1,5 +1,4 @@ //// [strictNullChecksNoWidening.ts] - var a1 = null; var a2 = undefined; var a3 = void 0; diff --git a/tests/baselines/reference/strictNullChecksNoWidening.symbols b/tests/baselines/reference/strictNullChecksNoWidening.symbols index a23a0d2e926c0..415ce613eb249 100644 --- a/tests/baselines/reference/strictNullChecksNoWidening.symbols +++ b/tests/baselines/reference/strictNullChecksNoWidening.symbols @@ -1,48 +1,47 @@ === tests/cases/conformance/types/typeRelationships/widenedTypes/strictNullChecksNoWidening.ts === - var a1 = null; ->a1 : Symbol(a1, Decl(strictNullChecksNoWidening.ts, 1, 3)) +>a1 : Symbol(a1, Decl(strictNullChecksNoWidening.ts, 0, 3)) var a2 = undefined; ->a2 : Symbol(a2, Decl(strictNullChecksNoWidening.ts, 2, 3)) +>a2 : Symbol(a2, Decl(strictNullChecksNoWidening.ts, 1, 3)) >undefined : Symbol(undefined) var a3 = void 0; ->a3 : Symbol(a3, Decl(strictNullChecksNoWidening.ts, 3, 3)) +>a3 : Symbol(a3, Decl(strictNullChecksNoWidening.ts, 2, 3)) var b1 = []; ->b1 : Symbol(b1, Decl(strictNullChecksNoWidening.ts, 5, 3)) +>b1 : Symbol(b1, Decl(strictNullChecksNoWidening.ts, 4, 3)) var b2 = [,]; ->b2 : Symbol(b2, Decl(strictNullChecksNoWidening.ts, 6, 3)) +>b2 : Symbol(b2, Decl(strictNullChecksNoWidening.ts, 5, 3)) var b3 = [undefined]; ->b3 : Symbol(b3, Decl(strictNullChecksNoWidening.ts, 7, 3)) +>b3 : Symbol(b3, Decl(strictNullChecksNoWidening.ts, 6, 3)) >undefined : Symbol(undefined) var b4 = [[], []]; ->b4 : Symbol(b4, Decl(strictNullChecksNoWidening.ts, 8, 3)) +>b4 : Symbol(b4, Decl(strictNullChecksNoWidening.ts, 7, 3)) var b5 = [[], [,]]; ->b5 : Symbol(b5, Decl(strictNullChecksNoWidening.ts, 9, 3)) +>b5 : Symbol(b5, Decl(strictNullChecksNoWidening.ts, 8, 3)) declare function f(x: T): T; ->f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 9, 19)) ->T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 11, 19)) ->x : Symbol(x, Decl(strictNullChecksNoWidening.ts, 11, 22)) ->T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 11, 19)) ->T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 11, 19)) +>f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 8, 19)) +>T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 10, 19)) +>x : Symbol(x, Decl(strictNullChecksNoWidening.ts, 10, 22)) +>T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 10, 19)) +>T : Symbol(T, Decl(strictNullChecksNoWidening.ts, 10, 19)) var c1 = f(null); ->c1 : Symbol(c1, Decl(strictNullChecksNoWidening.ts, 13, 3)) ->f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 9, 19)) +>c1 : Symbol(c1, Decl(strictNullChecksNoWidening.ts, 12, 3)) +>f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 8, 19)) var c2 = f(undefined); ->c2 : Symbol(c2, Decl(strictNullChecksNoWidening.ts, 14, 3)) ->f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 9, 19)) +>c2 : Symbol(c2, Decl(strictNullChecksNoWidening.ts, 13, 3)) +>f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 8, 19)) >undefined : Symbol(undefined) var c3 = f([]); ->c3 : Symbol(c3, Decl(strictNullChecksNoWidening.ts, 15, 3)) ->f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 9, 19)) +>c3 : Symbol(c3, Decl(strictNullChecksNoWidening.ts, 14, 3)) +>f : Symbol(f, Decl(strictNullChecksNoWidening.ts, 8, 19)) diff --git a/tests/baselines/reference/strictNullChecksNoWidening.types b/tests/baselines/reference/strictNullChecksNoWidening.types index a544f9cef94a4..ec4141b101812 100644 --- a/tests/baselines/reference/strictNullChecksNoWidening.types +++ b/tests/baselines/reference/strictNullChecksNoWidening.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/typeRelationships/widenedTypes/strictNullChecksNoWidening.ts === - var a1 = null; >a1 : null >null : null diff --git a/tests/baselines/reference/strictNullLogicalAndOr.js b/tests/baselines/reference/strictNullLogicalAndOr.js index f4dafe334b5e5..1b2d6d384e683 100644 --- a/tests/baselines/reference/strictNullLogicalAndOr.js +++ b/tests/baselines/reference/strictNullLogicalAndOr.js @@ -1,5 +1,4 @@ //// [strictNullLogicalAndOr.ts] - // Repro from #9113 let sinOrCos = Math.random() < .5; diff --git a/tests/baselines/reference/strictNullLogicalAndOr.symbols b/tests/baselines/reference/strictNullLogicalAndOr.symbols index 8bb0343b9c0f9..3dea02e8e8b32 100644 --- a/tests/baselines/reference/strictNullLogicalAndOr.symbols +++ b/tests/baselines/reference/strictNullLogicalAndOr.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/strictNullLogicalAndOr.ts === - // Repro from #9113 let sinOrCos = Math.random() < .5; ->sinOrCos : Symbol(sinOrCos, Decl(strictNullLogicalAndOr.ts, 3, 3)) +>sinOrCos : Symbol(sinOrCos, Decl(strictNullLogicalAndOr.ts, 2, 3)) >Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >random : Symbol(Math.random, Decl(lib.d.ts, --, --)) let choice = sinOrCos && Math.sin || Math.cos; ->choice : Symbol(choice, Decl(strictNullLogicalAndOr.ts, 4, 3)) ->sinOrCos : Symbol(sinOrCos, Decl(strictNullLogicalAndOr.ts, 3, 3)) +>choice : Symbol(choice, Decl(strictNullLogicalAndOr.ts, 3, 3)) +>sinOrCos : Symbol(sinOrCos, Decl(strictNullLogicalAndOr.ts, 2, 3)) >Math.sin : Symbol(Math.sin, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >sin : Symbol(Math.sin, Decl(lib.d.ts, --, --)) @@ -19,26 +18,26 @@ let choice = sinOrCos && Math.sin || Math.cos; >cos : Symbol(Math.cos, Decl(lib.d.ts, --, --)) choice(Math.PI); ->choice : Symbol(choice, Decl(strictNullLogicalAndOr.ts, 4, 3)) +>choice : Symbol(choice, Decl(strictNullLogicalAndOr.ts, 3, 3)) >Math.PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >PI : Symbol(Math.PI, Decl(lib.d.ts, --, --)) function sq(n?: number): number { ->sq : Symbol(sq, Decl(strictNullLogicalAndOr.ts, 6, 16)) ->n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 8, 12)) +>sq : Symbol(sq, Decl(strictNullLogicalAndOr.ts, 5, 16)) +>n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 7, 12)) const r = n !== undefined && n*n || 0; ->r : Symbol(r, Decl(strictNullLogicalAndOr.ts, 9, 7)) ->n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 8, 12)) +>r : Symbol(r, Decl(strictNullLogicalAndOr.ts, 8, 7)) +>n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 7, 12)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 8, 12)) ->n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 8, 12)) +>n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 7, 12)) +>n : Symbol(n, Decl(strictNullLogicalAndOr.ts, 7, 12)) return r; ->r : Symbol(r, Decl(strictNullLogicalAndOr.ts, 9, 7)) +>r : Symbol(r, Decl(strictNullLogicalAndOr.ts, 8, 7)) } sq(3); ->sq : Symbol(sq, Decl(strictNullLogicalAndOr.ts, 6, 16)) +>sq : Symbol(sq, Decl(strictNullLogicalAndOr.ts, 5, 16)) diff --git a/tests/baselines/reference/strictNullLogicalAndOr.types b/tests/baselines/reference/strictNullLogicalAndOr.types index 50eb6586a0f2e..33881b5d9d72c 100644 --- a/tests/baselines/reference/strictNullLogicalAndOr.types +++ b/tests/baselines/reference/strictNullLogicalAndOr.types @@ -1,5 +1,4 @@ === tests/cases/compiler/strictNullLogicalAndOr.ts === - // Repro from #9113 let sinOrCos = Math.random() < .5; diff --git a/tests/baselines/reference/stringIncludes.js b/tests/baselines/reference/stringIncludes.js index 055d7d8beebd6..e5c2d20ae56db 100644 --- a/tests/baselines/reference/stringIncludes.js +++ b/tests/baselines/reference/stringIncludes.js @@ -1,5 +1,4 @@ //// [stringIncludes.ts] - var includes: boolean; includes = "abcde".includes("cd"); includes = "abcde".includes("cd", 2); diff --git a/tests/baselines/reference/stringIncludes.symbols b/tests/baselines/reference/stringIncludes.symbols index 5b2bf4b7afa2f..ba3c5ade73edb 100644 --- a/tests/baselines/reference/stringIncludes.symbols +++ b/tests/baselines/reference/stringIncludes.symbols @@ -1,15 +1,14 @@ === tests/cases/compiler/stringIncludes.ts === - var includes: boolean; ->includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3)) +>includes : Symbol(includes, Decl(stringIncludes.ts, 0, 3)) includes = "abcde".includes("cd"); ->includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3)) +>includes : Symbol(includes, Decl(stringIncludes.ts, 0, 3)) >"abcde".includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) includes = "abcde".includes("cd", 2); ->includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3)) +>includes : Symbol(includes, Decl(stringIncludes.ts, 0, 3)) >"abcde".includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) >includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --)) diff --git a/tests/baselines/reference/stringIncludes.types b/tests/baselines/reference/stringIncludes.types index 1dce85fcec708..c97ad7eefa31f 100644 --- a/tests/baselines/reference/stringIncludes.types +++ b/tests/baselines/reference/stringIncludes.types @@ -1,5 +1,4 @@ === tests/cases/compiler/stringIncludes.ts === - var includes: boolean; >includes : boolean diff --git a/tests/baselines/reference/stringLiteralCheckedInIf01.js b/tests/baselines/reference/stringLiteralCheckedInIf01.js index 161c39b96efa4..8de3a3bfc34e4 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf01.js +++ b/tests/baselines/reference/stringLiteralCheckedInIf01.js @@ -1,5 +1,4 @@ //// [stringLiteralCheckedInIf01.ts] - type S = "a" | "b"; type T = S[] | S; diff --git a/tests/baselines/reference/stringLiteralCheckedInIf01.symbols b/tests/baselines/reference/stringLiteralCheckedInIf01.symbols index 1b4d5e6b07125..c77a9b0d4118e 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf01.symbols +++ b/tests/baselines/reference/stringLiteralCheckedInIf01.symbols @@ -1,33 +1,32 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf01.ts === - type S = "a" | "b"; >S : Symbol(S, Decl(stringLiteralCheckedInIf01.ts, 0, 0)) type T = S[] | S; ->T : Symbol(T, Decl(stringLiteralCheckedInIf01.ts, 1, 19)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf01.ts, 0, 19)) >S : Symbol(S, Decl(stringLiteralCheckedInIf01.ts, 0, 0)) >S : Symbol(S, Decl(stringLiteralCheckedInIf01.ts, 0, 0)) function f(foo: T) { ->f : Symbol(f, Decl(stringLiteralCheckedInIf01.ts, 2, 17)) ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) ->T : Symbol(T, Decl(stringLiteralCheckedInIf01.ts, 1, 19)) +>f : Symbol(f, Decl(stringLiteralCheckedInIf01.ts, 1, 17)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf01.ts, 0, 19)) if (foo === "a") { ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) return foo; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) } else if (foo === "b") { ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) return foo; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) } else { return (foo as S[])[0]; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 4, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf01.ts, 3, 11)) >S : Symbol(S, Decl(stringLiteralCheckedInIf01.ts, 0, 0)) } } diff --git a/tests/baselines/reference/stringLiteralCheckedInIf01.types b/tests/baselines/reference/stringLiteralCheckedInIf01.types index 2505870f9a934..822bc5690015e 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf01.types +++ b/tests/baselines/reference/stringLiteralCheckedInIf01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf01.ts === - type S = "a" | "b"; >S : S diff --git a/tests/baselines/reference/stringLiteralCheckedInIf02.js b/tests/baselines/reference/stringLiteralCheckedInIf02.js index 22bd6359f6187..4e9e7220ae7ef 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf02.js +++ b/tests/baselines/reference/stringLiteralCheckedInIf02.js @@ -1,5 +1,4 @@ //// [stringLiteralCheckedInIf02.ts] - type S = "a" | "b"; type T = S[] | S; diff --git a/tests/baselines/reference/stringLiteralCheckedInIf02.symbols b/tests/baselines/reference/stringLiteralCheckedInIf02.symbols index 629f990b91260..33d7e0f41cce3 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf02.symbols +++ b/tests/baselines/reference/stringLiteralCheckedInIf02.symbols @@ -1,39 +1,38 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf02.ts === - type S = "a" | "b"; >S : Symbol(S, Decl(stringLiteralCheckedInIf02.ts, 0, 0)) type T = S[] | S; ->T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 1, 19)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 0, 19)) >S : Symbol(S, Decl(stringLiteralCheckedInIf02.ts, 0, 0)) >S : Symbol(S, Decl(stringLiteralCheckedInIf02.ts, 0, 0)) function isS(t: T): t is S { ->isS : Symbol(isS, Decl(stringLiteralCheckedInIf02.ts, 2, 17)) ->t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 4, 13)) ->T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 1, 19)) ->t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 4, 13)) +>isS : Symbol(isS, Decl(stringLiteralCheckedInIf02.ts, 1, 17)) +>t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 3, 13)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 0, 19)) +>t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 3, 13)) >S : Symbol(S, Decl(stringLiteralCheckedInIf02.ts, 0, 0)) return t === "a" || t === "b"; ->t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 4, 13)) ->t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 4, 13)) +>t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 3, 13)) +>t : Symbol(t, Decl(stringLiteralCheckedInIf02.ts, 3, 13)) } function f(foo: T) { ->f : Symbol(f, Decl(stringLiteralCheckedInIf02.ts, 6, 1)) ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 8, 11)) ->T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 1, 19)) +>f : Symbol(f, Decl(stringLiteralCheckedInIf02.ts, 5, 1)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 7, 11)) +>T : Symbol(T, Decl(stringLiteralCheckedInIf02.ts, 0, 19)) if (isS(foo)) { ->isS : Symbol(isS, Decl(stringLiteralCheckedInIf02.ts, 2, 17)) ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 8, 11)) +>isS : Symbol(isS, Decl(stringLiteralCheckedInIf02.ts, 1, 17)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 7, 11)) return foo; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 8, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 7, 11)) } else { return foo[0]; ->foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 8, 11)) +>foo : Symbol(foo, Decl(stringLiteralCheckedInIf02.ts, 7, 11)) } } diff --git a/tests/baselines/reference/stringLiteralCheckedInIf02.types b/tests/baselines/reference/stringLiteralCheckedInIf02.types index 6589c85222af9..586cf1013989f 100644 --- a/tests/baselines/reference/stringLiteralCheckedInIf02.types +++ b/tests/baselines/reference/stringLiteralCheckedInIf02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf02.ts === - type S = "a" | "b"; >S : S diff --git a/tests/baselines/reference/stringLiteralMatchedInSwitch01.js b/tests/baselines/reference/stringLiteralMatchedInSwitch01.js index b9b24cf0c66b3..af606d03e94b5 100644 --- a/tests/baselines/reference/stringLiteralMatchedInSwitch01.js +++ b/tests/baselines/reference/stringLiteralMatchedInSwitch01.js @@ -1,5 +1,4 @@ //// [stringLiteralMatchedInSwitch01.ts] - type S = "a" | "b"; type T = S[] | S; diff --git a/tests/baselines/reference/stringLiteralMatchedInSwitch01.symbols b/tests/baselines/reference/stringLiteralMatchedInSwitch01.symbols index 0323371c3070d..29ad91f0ea2a3 100644 --- a/tests/baselines/reference/stringLiteralMatchedInSwitch01.symbols +++ b/tests/baselines/reference/stringLiteralMatchedInSwitch01.symbols @@ -1,27 +1,26 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralMatchedInSwitch01.ts === - type S = "a" | "b"; >S : Symbol(S, Decl(stringLiteralMatchedInSwitch01.ts, 0, 0)) type T = S[] | S; ->T : Symbol(T, Decl(stringLiteralMatchedInSwitch01.ts, 1, 19)) +>T : Symbol(T, Decl(stringLiteralMatchedInSwitch01.ts, 0, 19)) >S : Symbol(S, Decl(stringLiteralMatchedInSwitch01.ts, 0, 0)) >S : Symbol(S, Decl(stringLiteralMatchedInSwitch01.ts, 0, 0)) var foo: T; ->foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 4, 3)) ->T : Symbol(T, Decl(stringLiteralMatchedInSwitch01.ts, 1, 19)) +>foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 3, 3)) +>T : Symbol(T, Decl(stringLiteralMatchedInSwitch01.ts, 0, 19)) switch (foo) { ->foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 4, 3)) +>foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 3, 3)) case "a": case "b": break; default: foo = (foo as S[])[0]; ->foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 4, 3)) ->foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 4, 3)) +>foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 3, 3)) +>foo : Symbol(foo, Decl(stringLiteralMatchedInSwitch01.ts, 3, 3)) >S : Symbol(S, Decl(stringLiteralMatchedInSwitch01.ts, 0, 0)) break; diff --git a/tests/baselines/reference/stringLiteralMatchedInSwitch01.types b/tests/baselines/reference/stringLiteralMatchedInSwitch01.types index 5f2d68d47cdaf..bbdc014040da4 100644 --- a/tests/baselines/reference/stringLiteralMatchedInSwitch01.types +++ b/tests/baselines/reference/stringLiteralMatchedInSwitch01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralMatchedInSwitch01.ts === - type S = "a" | "b"; >S : S diff --git a/tests/baselines/reference/stringLiteralTypeAssertion01.js b/tests/baselines/reference/stringLiteralTypeAssertion01.js index 7877004cf01ab..080c19854a52e 100644 --- a/tests/baselines/reference/stringLiteralTypeAssertion01.js +++ b/tests/baselines/reference/stringLiteralTypeAssertion01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypeAssertion01.ts] - type S = "a" | "b"; type T = S[] | S; diff --git a/tests/baselines/reference/stringLiteralTypeAssertion01.symbols b/tests/baselines/reference/stringLiteralTypeAssertion01.symbols index 1491a32b6f8bf..4129be8a0e8e1 100644 --- a/tests/baselines/reference/stringLiteralTypeAssertion01.symbols +++ b/tests/baselines/reference/stringLiteralTypeAssertion01.symbols @@ -1,83 +1,82 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts === - type S = "a" | "b"; >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) type T = S[] | S; ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) var s: S; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) var t: T; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) var str: string; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) //////////////// s = t; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) s = t as S; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) s = str; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) s = str as S; ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) >S : Symbol(S, Decl(stringLiteralTypeAssertion01.ts, 0, 0)) //////////////// t = s; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) t = s as T; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) t = str; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) t = str as T; ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 1, 19)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>T : Symbol(T, Decl(stringLiteralTypeAssertion01.ts, 0, 19)) //////////////// str = s; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) str = s as string; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>s : Symbol(s, Decl(stringLiteralTypeAssertion01.ts, 3, 3)) str = t; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) str = t as string; ->str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 6, 3)) ->t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>str : Symbol(str, Decl(stringLiteralTypeAssertion01.ts, 5, 3)) +>t : Symbol(t, Decl(stringLiteralTypeAssertion01.ts, 4, 3)) diff --git a/tests/baselines/reference/stringLiteralTypeAssertion01.types b/tests/baselines/reference/stringLiteralTypeAssertion01.types index 051b8ffc573f3..ea620ace34f59 100644 --- a/tests/baselines/reference/stringLiteralTypeAssertion01.types +++ b/tests/baselines/reference/stringLiteralTypeAssertion01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts === - type S = "a" | "b"; >S : S diff --git a/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.errors.txt b/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.errors.txt index 1596d74281aa3..4d870aa77b785 100644 --- a/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndLogicalOrExpressions01.ts(8,5): error TS2322: Type 'string' is not assignable to type '"foo" | "bar"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndLogicalOrExpressions01.ts(7,5): error TS2322: Type 'string' is not assignable to type '"foo" | "bar"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndLogicalOrExpressions01.ts (1 errors) ==== - declare function myRandBool(): boolean; let a: "foo" = "foo"; diff --git a/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.js b/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.js index 33dce2041e36e..255121498e99d 100644 --- a/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.js +++ b/tests/baselines/reference/stringLiteralTypesAndLogicalOrExpressions01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAndLogicalOrExpressions01.ts] - declare function myRandBool(): boolean; let a: "foo" = "foo"; diff --git a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.js b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.js index 1fe1225c6f40d..f5bbe55aae47a 100644 --- a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.js +++ b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAndParenthesizedExpressions01.ts] - declare function myRandBool(): boolean; let a: "foo" = ("foo"); diff --git a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.symbols b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.symbols index 2206a5185c1af..98d495c8389a1 100644 --- a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.symbols +++ b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndParenthesizedExpressions01.ts === - declare function myRandBool(): boolean; >myRandBool : Symbol(myRandBool, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 0, 0)) let a: "foo" = ("foo"); ->a : Symbol(a, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 2, 3)) let b: "foo" | "bar" = ("foo"); ->b : Symbol(b, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 4, 3)) +>b : Symbol(b, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 3, 3)) let c: "foo" = (myRandBool ? "foo" : ("foo")); ->c : Symbol(c, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 5, 3)) +>c : Symbol(c, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 4, 3)) >myRandBool : Symbol(myRandBool, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 0, 0)) let d: "foo" | "bar" = (myRandBool ? "foo" : ("bar")); ->d : Symbol(d, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 6, 3)) +>d : Symbol(d, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 5, 3)) >myRandBool : Symbol(myRandBool, Decl(stringLiteralTypesAndParenthesizedExpressions01.ts, 0, 0)) diff --git a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.types b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.types index 0bb2e1dd3c7b8..0533ab3915183 100644 --- a/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.types +++ b/tests/baselines/reference/stringLiteralTypesAndParenthesizedExpressions01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndParenthesizedExpressions01.ts === - declare function myRandBool(): boolean; >myRandBool : () => boolean diff --git a/tests/baselines/reference/stringLiteralTypesAndTuples01.js b/tests/baselines/reference/stringLiteralTypesAndTuples01.js index 4700cc65730dc..11aebfc04043a 100644 --- a/tests/baselines/reference/stringLiteralTypesAndTuples01.js +++ b/tests/baselines/reference/stringLiteralTypesAndTuples01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAndTuples01.ts] - // Should all be strings. let [hello, brave, newish, world] = ["Hello", "Brave", "New", "World"]; diff --git a/tests/baselines/reference/stringLiteralTypesAndTuples01.symbols b/tests/baselines/reference/stringLiteralTypesAndTuples01.symbols index b7ca53517ca15..523cb8bafa045 100644 --- a/tests/baselines/reference/stringLiteralTypesAndTuples01.symbols +++ b/tests/baselines/reference/stringLiteralTypesAndTuples01.symbols @@ -1,41 +1,40 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndTuples01.ts === - // Should all be strings. let [hello, brave, newish, world] = ["Hello", "Brave", "New", "World"]; ->hello : Symbol(hello, Decl(stringLiteralTypesAndTuples01.ts, 2, 5)) ->brave : Symbol(brave, Decl(stringLiteralTypesAndTuples01.ts, 2, 11)) ->newish : Symbol(newish, Decl(stringLiteralTypesAndTuples01.ts, 2, 18)) ->world : Symbol(world, Decl(stringLiteralTypesAndTuples01.ts, 2, 26)) +>hello : Symbol(hello, Decl(stringLiteralTypesAndTuples01.ts, 1, 5)) +>brave : Symbol(brave, Decl(stringLiteralTypesAndTuples01.ts, 1, 11)) +>newish : Symbol(newish, Decl(stringLiteralTypesAndTuples01.ts, 1, 18)) +>world : Symbol(world, Decl(stringLiteralTypesAndTuples01.ts, 1, 26)) type RexOrRaptor = "t-rex" | "raptor" ->RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 2, 71)) +>RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 1, 71)) let [im, a, dinosaur]: ["I'm", "a", RexOrRaptor] = ['I\'m', 'a', 't-rex']; ->im : Symbol(im, Decl(stringLiteralTypesAndTuples01.ts, 5, 5)) ->a : Symbol(a, Decl(stringLiteralTypesAndTuples01.ts, 5, 8)) ->dinosaur : Symbol(dinosaur, Decl(stringLiteralTypesAndTuples01.ts, 5, 11)) ->RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 2, 71)) +>im : Symbol(im, Decl(stringLiteralTypesAndTuples01.ts, 4, 5)) +>a : Symbol(a, Decl(stringLiteralTypesAndTuples01.ts, 4, 8)) +>dinosaur : Symbol(dinosaur, Decl(stringLiteralTypesAndTuples01.ts, 4, 11)) +>RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 1, 71)) rawr(dinosaur); ->rawr : Symbol(rawr, Decl(stringLiteralTypesAndTuples01.ts, 7, 15)) ->dinosaur : Symbol(dinosaur, Decl(stringLiteralTypesAndTuples01.ts, 5, 11)) +>rawr : Symbol(rawr, Decl(stringLiteralTypesAndTuples01.ts, 6, 15)) +>dinosaur : Symbol(dinosaur, Decl(stringLiteralTypesAndTuples01.ts, 4, 11)) function rawr(dino: RexOrRaptor) { ->rawr : Symbol(rawr, Decl(stringLiteralTypesAndTuples01.ts, 7, 15)) ->dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 9, 14)) ->RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 2, 71)) +>rawr : Symbol(rawr, Decl(stringLiteralTypesAndTuples01.ts, 6, 15)) +>dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 8, 14)) +>RexOrRaptor : Symbol(RexOrRaptor, Decl(stringLiteralTypesAndTuples01.ts, 1, 71)) if (dino === "t-rex") { ->dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 9, 14)) +>dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 8, 14)) return "ROAAAAR!"; } if (dino === "raptor") { ->dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 9, 14)) +>dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 8, 14)) return "yip yip!"; } throw "Unexpected " + dino; ->dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 9, 14)) +>dino : Symbol(dino, Decl(stringLiteralTypesAndTuples01.ts, 8, 14)) } diff --git a/tests/baselines/reference/stringLiteralTypesAndTuples01.types b/tests/baselines/reference/stringLiteralTypesAndTuples01.types index f69e36cf541ca..2adce12cd1e2a 100644 --- a/tests/baselines/reference/stringLiteralTypesAndTuples01.types +++ b/tests/baselines/reference/stringLiteralTypesAndTuples01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAndTuples01.ts === - // Should all be strings. let [hello, brave, newish, world] = ["Hello", "Brave", "New", "World"]; >hello : string diff --git a/tests/baselines/reference/stringLiteralTypesAsTags01.js b/tests/baselines/reference/stringLiteralTypesAsTags01.js index b7b3872ce6614..adecab0b1b8a9 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags01.js +++ b/tests/baselines/reference/stringLiteralTypesAsTags01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTags01.ts] - type Kind = "A" | "B" interface Entity { diff --git a/tests/baselines/reference/stringLiteralTypesAsTags01.symbols b/tests/baselines/reference/stringLiteralTypesAsTags01.symbols index f092e1f7a50d3..9f97836f5b6fc 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags01.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTags01.symbols @@ -1,112 +1,111 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts === - type Kind = "A" | "B" >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0)) interface Entity { ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) kind: Kind; ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 3, 18)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 2, 18)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0)) } interface A extends Entity { ->A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 5, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 4, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) kind: "A"; ->kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags01.ts, 7, 28)) +>kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags01.ts, 6, 28)) a: number; ->a : Symbol(A.a, Decl(stringLiteralTypesAsTags01.ts, 8, 14)) +>a : Symbol(A.a, Decl(stringLiteralTypesAsTags01.ts, 7, 14)) } interface B extends Entity { ->B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 10, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 9, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) kind: "B"; ->kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags01.ts, 12, 28)) +>kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags01.ts, 11, 28)) b: string; ->b : Symbol(B.b, Decl(stringLiteralTypesAsTags01.ts, 13, 14)) +>b : Symbol(B.b, Decl(stringLiteralTypesAsTags01.ts, 12, 14)) } function hasKind(entity: Entity, kind: "A"): entity is A; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 16, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 16, 32)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 16, 17)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 4, 1)) + +function hasKind(entity: Entity, kind: "B"): entity is B; +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 17, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) >kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 17, 32)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 17, 17)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 5, 1)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 9, 1)) -function hasKind(entity: Entity, kind: "B"): entity is B; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) +function hasKind(entity: Entity, kind: Kind): entity is Entity; +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 18, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) >kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 18, 32)) +>Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 18, 17)) ->B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 10, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) -function hasKind(entity: Entity, kind: Kind): entity is Entity; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) +function hasKind(entity: Entity, kind: Kind): boolean { +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 19, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 0, 21)) >kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 19, 32)) ->Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 19, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) - -function hasKind(entity: Entity, kind: Kind): boolean { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 20, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 20, 32)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0)) return entity.kind === kind; ->entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 3, 18)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 20, 17)) ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 3, 18)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 20, 32)) +>entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 2, 18)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 19, 17)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 2, 18)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 19, 32)) } let x: A = { ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 5, 1)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 4, 1)) kind: "A", ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 24, 12)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 23, 12)) a: 100, ->a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 25, 14)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 24, 14)) } if (hasKind(x, "A")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 30, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 29, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) } else { let b = x; ->b : Symbol(b, Decl(stringLiteralTypesAsTags01.ts, 33, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>b : Symbol(b, Decl(stringLiteralTypesAsTags01.ts, 32, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) } if (!hasKind(x, "B")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 14, 1), Decl(stringLiteralTypesAsTags01.ts, 16, 57), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 63)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesAsTags01.ts, 37, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>c : Symbol(c, Decl(stringLiteralTypesAsTags01.ts, 36, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) } else { let d = x; ->d : Symbol(d, Decl(stringLiteralTypesAsTags01.ts, 40, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3)) +>d : Symbol(d, Decl(stringLiteralTypesAsTags01.ts, 39, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 23, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesAsTags01.types b/tests/baselines/reference/stringLiteralTypesAsTags01.types index ad53fb01c7987..6caf851a72648 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags01.types +++ b/tests/baselines/reference/stringLiteralTypesAsTags01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts === - type Kind = "A" | "B" >Kind : Kind diff --git a/tests/baselines/reference/stringLiteralTypesAsTags02.js b/tests/baselines/reference/stringLiteralTypesAsTags02.js index e83f1ad46ee90..299686b080221 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags02.js +++ b/tests/baselines/reference/stringLiteralTypesAsTags02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTags02.ts] - type Kind = "A" | "B" interface Entity { diff --git a/tests/baselines/reference/stringLiteralTypesAsTags02.symbols b/tests/baselines/reference/stringLiteralTypesAsTags02.symbols index 1cf73015ea7c9..8cc3de5fc744d 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags02.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTags02.symbols @@ -1,106 +1,105 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags02.ts === - type Kind = "A" | "B" >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags02.ts, 0, 0)) interface Entity { ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) kind: Kind; ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 3, 18)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 2, 18)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags02.ts, 0, 0)) } interface A extends Entity { ->A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 5, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 4, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) kind: "A"; ->kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags02.ts, 7, 28)) +>kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags02.ts, 6, 28)) a: number; ->a : Symbol(A.a, Decl(stringLiteralTypesAsTags02.ts, 8, 14)) +>a : Symbol(A.a, Decl(stringLiteralTypesAsTags02.ts, 7, 14)) } interface B extends Entity { ->B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 10, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 9, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) kind: "B"; ->kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags02.ts, 12, 28)) +>kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags02.ts, 11, 28)) b: string; ->b : Symbol(B.b, Decl(stringLiteralTypesAsTags02.ts, 13, 14)) +>b : Symbol(B.b, Decl(stringLiteralTypesAsTags02.ts, 12, 14)) } function hasKind(entity: Entity, kind: "A"): entity is A; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 16, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 16, 32)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 16, 17)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 4, 1)) + +function hasKind(entity: Entity, kind: "B"): entity is B; +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 17, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) >kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 17, 32)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 17, 17)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 5, 1)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 9, 1)) -function hasKind(entity: Entity, kind: "B"): entity is B; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) +function hasKind(entity: Entity, kind: Kind): entity is (A | B) { +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 18, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 0, 21)) >kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 18, 32)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 18, 17)) ->B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 10, 1)) - -function hasKind(entity: Entity, kind: Kind): entity is (A | B) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 19, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags02.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 19, 32)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags02.ts, 0, 0)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 19, 17)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 5, 1)) ->B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 10, 1)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 18, 17)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 4, 1)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags02.ts, 9, 1)) return entity.kind === kind; ->entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 3, 18)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 19, 17)) ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 3, 18)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 19, 32)) +>entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 2, 18)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags02.ts, 18, 17)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags02.ts, 2, 18)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 18, 32)) } let x: A = { ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 5, 1)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags02.ts, 4, 1)) kind: "A", ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 23, 12)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags02.ts, 22, 12)) a: 100, ->a : Symbol(a, Decl(stringLiteralTypesAsTags02.ts, 24, 14)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags02.ts, 23, 14)) } if (hasKind(x, "A")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesAsTags02.ts, 29, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags02.ts, 28, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) } else { let b = x; ->b : Symbol(b, Decl(stringLiteralTypesAsTags02.ts, 32, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>b : Symbol(b, Decl(stringLiteralTypesAsTags02.ts, 31, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) } if (!hasKind(x, "B")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 15, 1), Decl(stringLiteralTypesAsTags02.ts, 17, 57), Decl(stringLiteralTypesAsTags02.ts, 18, 57)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags02.ts, 14, 1), Decl(stringLiteralTypesAsTags02.ts, 16, 57), Decl(stringLiteralTypesAsTags02.ts, 17, 57)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesAsTags02.ts, 36, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>c : Symbol(c, Decl(stringLiteralTypesAsTags02.ts, 35, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) } else { let d = x; ->d : Symbol(d, Decl(stringLiteralTypesAsTags02.ts, 39, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 23, 3)) +>d : Symbol(d, Decl(stringLiteralTypesAsTags02.ts, 38, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags02.ts, 22, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesAsTags02.types b/tests/baselines/reference/stringLiteralTypesAsTags02.types index 2e2cb2831b666..f90ea6c6a0645 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags02.types +++ b/tests/baselines/reference/stringLiteralTypesAsTags02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags02.ts === - type Kind = "A" | "B" >Kind : Kind diff --git a/tests/baselines/reference/stringLiteralTypesAsTags03.js b/tests/baselines/reference/stringLiteralTypesAsTags03.js index bb2ed56040e37..761037dda2d2a 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags03.js +++ b/tests/baselines/reference/stringLiteralTypesAsTags03.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTags03.ts] - type Kind = "A" | "B" interface Entity { diff --git a/tests/baselines/reference/stringLiteralTypesAsTags03.symbols b/tests/baselines/reference/stringLiteralTypesAsTags03.symbols index 6f7e522d55ba0..b76619e8e915c 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags03.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTags03.symbols @@ -1,36 +1,35 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags03.ts === - type Kind = "A" | "B" >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags03.ts, 0, 0)) interface Entity { ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) kind: Kind; ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 3, 18)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 2, 18)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags03.ts, 0, 0)) } interface A extends Entity { ->A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 5, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 4, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) kind: "A"; ->kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags03.ts, 7, 28)) +>kind : Symbol(A.kind, Decl(stringLiteralTypesAsTags03.ts, 6, 28)) a: number; ->a : Symbol(A.a, Decl(stringLiteralTypesAsTags03.ts, 8, 14)) +>a : Symbol(A.a, Decl(stringLiteralTypesAsTags03.ts, 7, 14)) } interface B extends Entity { ->B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 10, 1)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 9, 1)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) kind: "B"; ->kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags03.ts, 12, 28)) +>kind : Symbol(B.kind, Decl(stringLiteralTypesAsTags03.ts, 11, 28)) b: string; ->b : Symbol(B.b, Decl(stringLiteralTypesAsTags03.ts, 13, 14)) +>b : Symbol(B.b, Decl(stringLiteralTypesAsTags03.ts, 12, 14)) } // Currently (2015-12-14), we write '"A" | "A"' and '"B" | "B"' to avoid @@ -38,72 +37,72 @@ interface B extends Entity { // That way, we can avoid the need to look for a compatible overload // signature and simply check compatibility with the implementation. function hasKind(entity: Entity, kind: "A" | "A"): entity is A; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 20, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 20, 32)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 20, 17)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 4, 1)) + +function hasKind(entity: Entity, kind: "B" | "B"): entity is B; +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 21, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) >kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 21, 32)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 21, 17)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 5, 1)) +>B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 9, 1)) -function hasKind(entity: Entity, kind: "B" | "B"): entity is B; ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) +function hasKind(entity: Entity, kind: Kind): entity is Entity { +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) >entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) >kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 22, 32)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17)) ->B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 10, 1)) - -function hasKind(entity: Entity, kind: Kind): entity is Entity { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 23, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 23, 32)) >Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags03.ts, 0, 0)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 23, 17)) ->Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17)) +>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 0, 21)) return entity.kind === kind; ->entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 3, 18)) ->entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 23, 17)) ->kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 3, 18)) ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 23, 32)) +>entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 2, 18)) +>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17)) +>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 2, 18)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 22, 32)) } let x: A = { ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) ->A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 5, 1)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) +>A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 4, 1)) kind: "A", ->kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 27, 12)) +>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 26, 12)) a: 100, ->a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 28, 14)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 27, 14)) } if (hasKind(x, "A")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 33, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 32, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) } else { let b = x; ->b : Symbol(b, Decl(stringLiteralTypesAsTags03.ts, 36, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>b : Symbol(b, Decl(stringLiteralTypesAsTags03.ts, 35, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) } if (!hasKind(x, "B")) { ->hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 14, 1), Decl(stringLiteralTypesAsTags03.ts, 20, 63), Decl(stringLiteralTypesAsTags03.ts, 21, 63)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesAsTags03.ts, 40, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>c : Symbol(c, Decl(stringLiteralTypesAsTags03.ts, 39, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) } else { let d = x; ->d : Symbol(d, Decl(stringLiteralTypesAsTags03.ts, 43, 7)) ->x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3)) +>d : Symbol(d, Decl(stringLiteralTypesAsTags03.ts, 42, 7)) +>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 26, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesAsTags03.types b/tests/baselines/reference/stringLiteralTypesAsTags03.types index 17507c1036fef..64622e28ac828 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTags03.types +++ b/tests/baselines/reference/stringLiteralTypesAsTags03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags03.ts === - type Kind = "A" | "B" >Kind : Kind diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.js b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.js index 4f49d326ec04f..018f6a0d415f1 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.js +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTypeParameterConstraint01.ts] - function foo(f: (x: T) => T) { return f; } diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.symbols b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.symbols index fd633b6e4d912..11f02a638aee2 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.symbols @@ -1,60 +1,59 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTypeParameterConstraint01.ts === - function foo(f: (x: T) => T) { >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 0)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 13)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 30)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 34)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 13)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 13)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 30)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 34)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 13)) return f; ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 1, 30)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 30)) } function bar(f: (x: T) => T) { ->bar : Symbol(bar, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 3, 1)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 13)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 38)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 42)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 13)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 13)) +>bar : Symbol(bar, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 2, 1)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 13)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 38)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 42)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 13)) return f; ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 5, 38)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 4, 38)) } let f = foo(x => x); ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 3)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 8, 3)) >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 0)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 12)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 12)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 8, 12)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 8, 12)) let fResult = f("foo"); ->fResult : Symbol(fResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 10, 3)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 3)) +>fResult : Symbol(fResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 9, 3)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 8, 3)) let g = foo((x => x)); ->g : Symbol(g, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 3)) +>g : Symbol(g, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 11, 3)) >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 0, 0)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 13)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 13)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 11, 13)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 11, 13)) let gResult = g("foo"); ->gResult : Symbol(gResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 13, 3)) ->g : Symbol(g, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 3)) +>gResult : Symbol(gResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 12, 3)) +>g : Symbol(g, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 11, 3)) let h = bar(x => x); ->h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) ->bar : Symbol(bar, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 3, 1)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 12)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 12)) +>h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 3)) +>bar : Symbol(bar, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 2, 1)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 12)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 12)) let hResult = h("foo"); ->hResult : Symbol(hResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 16, 3)) ->h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) +>hResult : Symbol(hResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) +>h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 3)) hResult = h("bar"); ->hResult : Symbol(hResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 16, 3)) ->h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) +>hResult : Symbol(hResult, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 15, 3)) +>h : Symbol(h, Decl(stringLiteralTypesAsTypeParameterConstraint01.ts, 14, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.types b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.types index fe9163fc81911..0ff65175866b6 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.types +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTypeParameterConstraint01.ts === - function foo(f: (x: T) => T) { >foo : (f: (x: T) => T) => (x: T) => T >T : T diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.js b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.js index 173e74a6eef86..0a0dbb3b83344 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.js +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesAsTypeParameterConstraint02.ts] - function foo(f: (x: T) => T) { return f; } diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.symbols b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.symbols index 1c5eb4577887e..fbf9a7fbb510e 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.symbols +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.symbols @@ -1,25 +1,24 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTypeParameterConstraint02.ts === - function foo(f: (x: T) => T) { >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 0)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 13)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 30)) ->x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 34)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 13)) ->T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 13)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 30)) +>x : Symbol(x, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 34)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 13)) +>T : Symbol(T, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 13)) return f; ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 1, 30)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 30)) } let f = foo((y: "foo" | "bar") => y === "foo" ? y : "foo"); ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 3)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 3)) >foo : Symbol(foo, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 0, 0)) ->y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 13)) ->y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 13)) ->y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 13)) +>y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 13)) +>y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 13)) +>y : Symbol(y, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 13)) let fResult = f("foo"); ->fResult : Symbol(fResult, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 6, 3)) ->f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 3)) +>fResult : Symbol(fResult, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 5, 3)) +>f : Symbol(f, Decl(stringLiteralTypesAsTypeParameterConstraint02.ts, 4, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.types b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.types index 3a1b8fdc05c83..d270c4dd4bbbd 100644 --- a/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.types +++ b/tests/baselines/reference/stringLiteralTypesAsTypeParameterConstraint02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTypeParameterConstraint02.ts === - function foo(f: (x: T) => T) { >foo : (f: (x: T) => T) => (x: T) => T >T : T diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.js b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.js index bdf06d393aafc..b8e3f62069098 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.js +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInUnionTypes01.ts] - type T = "foo" | "bar" | "baz"; var x: "foo" | "bar" | "baz" = undefined; diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.symbols b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.symbols index 15a8db13cd034..d4c8740d3b7db 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.symbols +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.symbols @@ -1,54 +1,53 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes01.ts === - type T = "foo" | "bar" | "baz"; >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes01.ts, 0, 0)) var x: "foo" | "bar" | "baz" = undefined; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) >undefined : Symbol(undefined) var y: T = undefined; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes01.ts, 0, 0)) >undefined : Symbol(undefined) if (x === "foo") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesInUnionTypes01.ts, 7, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesInUnionTypes01.ts, 6, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) } else if (x !== "bar") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) let b = x || y; ->b : Symbol(b, Decl(stringLiteralTypesInUnionTypes01.ts, 10, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) +>b : Symbol(b, Decl(stringLiteralTypesInUnionTypes01.ts, 9, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) } else { let c = x; ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes01.ts, 13, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes01.ts, 12, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) let d = y; ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes01.ts, 14, 7)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes01.ts, 13, 7)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) let e: (typeof x) | (typeof y) = c || d; ->e : Symbol(e, Decl(stringLiteralTypesInUnionTypes01.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes01.ts, 13, 7)) ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes01.ts, 14, 7)) +>e : Symbol(e, Decl(stringLiteralTypesInUnionTypes01.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes01.ts, 12, 7)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes01.ts, 13, 7)) } x = y; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) y = x; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 4, 3)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes01.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes01.ts, 2, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types index 96ec536f82fef..60a5383cafd7a 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes01.ts === - type T = "foo" | "bar" | "baz"; >T : "foo" | "bar" | "baz" diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.js b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.js index bca25e744c94b..8c0d5bd6fe303 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.js +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInUnionTypes02.ts] - type T = string | "foo" | "bar" | "baz"; var x: "foo" | "bar" | "baz" | string = undefined; diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.symbols b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.symbols index c35b7a0691b5c..aadc84b925673 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.symbols +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.symbols @@ -1,54 +1,53 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes02.ts === - type T = string | "foo" | "bar" | "baz"; >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes02.ts, 0, 0)) var x: "foo" | "bar" | "baz" | string = undefined; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) >undefined : Symbol(undefined) var y: T = undefined; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes02.ts, 0, 0)) >undefined : Symbol(undefined) if (x === "foo") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesInUnionTypes02.ts, 7, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesInUnionTypes02.ts, 6, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) } else if (x !== "bar") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) let b = x || y; ->b : Symbol(b, Decl(stringLiteralTypesInUnionTypes02.ts, 10, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) +>b : Symbol(b, Decl(stringLiteralTypesInUnionTypes02.ts, 9, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) } else { let c = x; ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes02.ts, 13, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes02.ts, 12, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) let d = y; ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes02.ts, 14, 7)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes02.ts, 13, 7)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) let e: (typeof x) | (typeof y) = c || d; ->e : Symbol(e, Decl(stringLiteralTypesInUnionTypes02.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes02.ts, 13, 7)) ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes02.ts, 14, 7)) +>e : Symbol(e, Decl(stringLiteralTypesInUnionTypes02.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes02.ts, 12, 7)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes02.ts, 13, 7)) } x = y; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) y = x; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 4, 3)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes02.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes02.ts, 2, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.types index 853781082985b..7d754d738a30d 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes02.types +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes02.ts === - type T = string | "foo" | "bar" | "baz"; >T : string diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.js b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.js index 6264c99c13df0..c635c2df53cf5 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.js +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInUnionTypes03.ts] - type T = number | "foo" | "bar"; var x: "foo" | "bar" | number; diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.symbols b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.symbols index 6d519e2422518..4b599d1e57ba2 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.symbols +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.symbols @@ -1,53 +1,52 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes03.ts === - type T = number | "foo" | "bar"; >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes03.ts, 0, 0)) var x: "foo" | "bar" | number; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) var y: T = undefined; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes03.ts, 0, 0)) >undefined : Symbol(undefined) if (x === "foo") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesInUnionTypes03.ts, 7, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesInUnionTypes03.ts, 6, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) } else if (x !== "bar") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) let b = x || y; ->b : Symbol(b, Decl(stringLiteralTypesInUnionTypes03.ts, 10, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) +>b : Symbol(b, Decl(stringLiteralTypesInUnionTypes03.ts, 9, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) } else { let c = x; ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes03.ts, 13, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes03.ts, 12, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) let d = y; ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes03.ts, 14, 7)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes03.ts, 13, 7)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) let e: (typeof x) | (typeof y) = c || d; ->e : Symbol(e, Decl(stringLiteralTypesInUnionTypes03.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes03.ts, 13, 7)) ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes03.ts, 14, 7)) +>e : Symbol(e, Decl(stringLiteralTypesInUnionTypes03.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes03.ts, 12, 7)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes03.ts, 13, 7)) } x = y; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) y = x; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 4, 3)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes03.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes03.ts, 2, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types index 99a729c7cf9c6..df1edad9da3cb 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes03.ts === - type T = number | "foo" | "bar"; >T : number | "foo" | "bar" diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.js b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.js index 85c9a30c49d8a..967014d58a62f 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.js +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInUnionTypes04.ts] - type T = "" | "foo"; let x: T = undefined; diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.symbols b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.symbols index 9904fa8613fbd..16289b25d1afc 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.symbols +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.symbols @@ -1,78 +1,77 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes04.ts === - type T = "" | "foo"; >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes04.ts, 0, 0)) let x: T = undefined; ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes04.ts, 0, 0)) >undefined : Symbol(undefined) let y: T = undefined; ->y : Symbol(y, Decl(stringLiteralTypesInUnionTypes04.ts, 4, 3)) +>y : Symbol(y, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) >T : Symbol(T, Decl(stringLiteralTypesInUnionTypes04.ts, 0, 0)) >undefined : Symbol(undefined) if (x === "") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesInUnionTypes04.ts, 7, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>a : Symbol(a, Decl(stringLiteralTypesInUnionTypes04.ts, 6, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (x !== "") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let b = x; ->b : Symbol(b, Decl(stringLiteralTypesInUnionTypes04.ts, 11, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>b : Symbol(b, Decl(stringLiteralTypesInUnionTypes04.ts, 10, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (x == "") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesInUnionTypes04.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>c : Symbol(c, Decl(stringLiteralTypesInUnionTypes04.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (x != "") { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let d = x; ->d : Symbol(d, Decl(stringLiteralTypesInUnionTypes04.ts, 19, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>d : Symbol(d, Decl(stringLiteralTypesInUnionTypes04.ts, 18, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (x) { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let e = x; ->e : Symbol(e, Decl(stringLiteralTypesInUnionTypes04.ts, 23, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>e : Symbol(e, Decl(stringLiteralTypesInUnionTypes04.ts, 22, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (!x) { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let f = x; ->f : Symbol(f, Decl(stringLiteralTypesInUnionTypes04.ts, 27, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>f : Symbol(f, Decl(stringLiteralTypesInUnionTypes04.ts, 26, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (!!x) { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let g = x; ->g : Symbol(g, Decl(stringLiteralTypesInUnionTypes04.ts, 31, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>g : Symbol(g, Decl(stringLiteralTypesInUnionTypes04.ts, 30, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } if (!!!x) { ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) let h = x; ->h : Symbol(h, Decl(stringLiteralTypesInUnionTypes04.ts, 35, 7)) ->x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 3, 3)) +>h : Symbol(h, Decl(stringLiteralTypesInUnionTypes04.ts, 34, 7)) +>x : Symbol(x, Decl(stringLiteralTypesInUnionTypes04.ts, 2, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types index 05b6b9b9b7aed..20f48d9e72dc8 100644 --- a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types +++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes04.ts === - type T = "" | "foo"; >T : T diff --git a/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.errors.txt b/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.errors.txt index 2534a07132e53..1e68c42b06da6 100644 --- a/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesInVariableDeclarations01.ts(5,7): error TS1155: 'const' declarations must be initialized. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesInVariableDeclarations01.ts(4,7): error TS1155: 'const' declarations must be initialized. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesInVariableDeclarations01.ts (1 errors) ==== - let a: ""; var b: "foo"; let c: "bar"; diff --git a/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.js b/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.js index 15a4ca5d580db..61f92b811c475 100644 --- a/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.js +++ b/tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesInVariableDeclarations01.ts] - let a: ""; var b: "foo"; let c: "bar"; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.errors.txt b/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.errors.txt index 8010b31a9d0b1..6372cb491e8c6 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts(15,1): error TS2322: Type '(x: "bar") => number' is not assignable to type '(x: "foo") => number'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts(14,1): error TS2322: Type '(x: "bar") => number' is not assignable to type '(x: "foo") => number'. Types of parameters 'x' and 'x' are incompatible. Type '"foo"' is not assignable to type '"bar"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts(16,1): error TS2322: Type '(x: "foo") => number' is not assignable to type '(x: "bar") => number'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts(15,1): error TS2322: Type '(x: "foo") => number' is not assignable to type '(x: "bar") => number'. Types of parameters 'x' and 'x' are incompatible. Type '"bar"' is not assignable to type '"foo"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability01.ts (2 errors) ==== - function f(x: "foo"): number; function f(x: string): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.js index 7b7c84165f32c..47211cb6d4c3e 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability01.ts] - function f(x: "foo"): number; function f(x: string): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.errors.txt b/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.errors.txt index 8fe5a676aaba6..fe4b3a935dc40 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts(15,1): error TS2322: Type '(x: "bar") => number' is not assignable to type '(x: "foo") => number'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts(14,1): error TS2322: Type '(x: "bar") => number' is not assignable to type '(x: "foo") => number'. Types of parameters 'x' and 'x' are incompatible. Type '"foo"' is not assignable to type '"bar"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts(16,1): error TS2322: Type '(x: "foo") => number' is not assignable to type '(x: "bar") => number'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts(15,1): error TS2322: Type '(x: "foo") => number' is not assignable to type '(x: "bar") => number'. Types of parameters 'x' and 'x' are incompatible. Type '"bar"' is not assignable to type '"foo"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability02.ts (2 errors) ==== - function f(x: "foo"): number; function f(x: "foo"): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.js index 7a8db4722a61d..f8d0f6fa91fe2 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability02.ts] - function f(x: "foo"): number; function f(x: "foo"): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.js index 1d9452a9c65c8..4f6c11d775fae 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability03.ts] - function f(x: "foo"): number; function f(x: string): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.symbols b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.symbols index 361f9e9db4dc0..bf54266e4a7b9 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.symbols @@ -1,40 +1,39 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability03.ts === - function f(x: "foo"): number; ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 11)) function f(x: string): number { ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 2, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 11)) return 0; } function g(x: "foo"): number; ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 5, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 5, 11)) function g(x: string): number { ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 7, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 5, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 11)) return 0; } let a = f; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 1, 29)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 10, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability03.ts, 0, 29)) let b = g; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 12, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 6, 29)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability03.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability03.ts, 5, 29)) a = b; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 12, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 10, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) b = a; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 12, 3)) ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability03.ts, 11, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability03.ts, 10, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.types b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.types index 00af8e6837397..b75b94626dc5f 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.types +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability03.ts === - function f(x: "foo"): number; >f : (x: "foo") => number >x : "foo" diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.js index 975c7d80cb5d1..ee6d63a744e4f 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability04.ts] - function f(x: "foo"): number; function f(x: "foo"): number { return 0; diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.symbols b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.symbols index 75f7d12c25f92..e55f7a3306a31 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.symbols @@ -1,40 +1,39 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability04.ts === - function f(x: "foo"): number; ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 11)) function f(x: "foo"): number { ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 2, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 11)) return 0; } function g(x: "foo"): number; ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 5, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 5, 11)) function g(x: "foo"): number { ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 7, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 5, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 11)) return 0; } let a = f; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 1, 29)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 10, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability04.ts, 0, 29)) let b = g; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 12, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 6, 29)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability04.ts, 3, 1), Decl(stringLiteralTypesOverloadAssignability04.ts, 5, 29)) a = b; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 12, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 10, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) b = a; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 12, 3)) ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability04.ts, 11, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability04.ts, 10, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.types b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.types index 694a300d3d37d..76f41f6337e0e 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.types +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability04.ts === - function f(x: "foo"): number; >f : (x: "foo") => number >x : "foo" diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.js b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.js index b08dbc040826b..aba8f4fe52d27 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.js +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloadAssignability05.ts] - function f(x: "foo"): number; function f(x: string): number; function f(x: string): number { diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.symbols b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.symbols index 9a59a7c929a1c..ca6f42f117493 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.symbols @@ -1,44 +1,43 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability05.ts === - function f(x: "foo"): number; ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 30)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 30)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 11)) function f(x: string): number; ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 30)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 30)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 11)) function f(x: string): number { ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 30)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 3, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 30)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 11)) return 0; } function g(x: "foo"): number; ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 5, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 6, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 6, 11)) function g(x: string): number { ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 5, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 29)) ->x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 8, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 6, 29)) +>x : Symbol(x, Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 11)) return 0; } let a = f; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 2, 30)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 11, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 0), Decl(stringLiteralTypesOverloadAssignability05.ts, 0, 29), Decl(stringLiteralTypesOverloadAssignability05.ts, 1, 30)) let b = g; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 13, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 5, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 7, 29)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloadAssignability05.ts, 4, 1), Decl(stringLiteralTypesOverloadAssignability05.ts, 6, 29)) a = b; ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 13, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 11, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) b = a; ->b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 13, 3)) ->a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) +>b : Symbol(b, Decl(stringLiteralTypesOverloadAssignability05.ts, 12, 3)) +>a : Symbol(a, Decl(stringLiteralTypesOverloadAssignability05.ts, 11, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.types b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.types index 925d254741154..925cda1997be2 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.types +++ b/tests/baselines/reference/stringLiteralTypesOverloadAssignability05.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloadAssignability05.ts === - function f(x: "foo"): number; >f : { (x: "foo"): number; (x: string): number; } >x : "foo" diff --git a/tests/baselines/reference/stringLiteralTypesOverloads01.js b/tests/baselines/reference/stringLiteralTypesOverloads01.js index dd050b5e4646c..06b8b46754392 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads01.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads01.ts] - type PrimitiveName = 'string' | 'number' | 'boolean'; function getFalsyPrimitive(x: "string"): string; diff --git a/tests/baselines/reference/stringLiteralTypesOverloads01.symbols b/tests/baselines/reference/stringLiteralTypesOverloads01.symbols index c92fe13407675..6409904e7d1d7 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads01.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloads01.symbols @@ -1,53 +1,52 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads01.ts === - type PrimitiveName = 'string' | 'number' | 'boolean'; >PrimitiveName : Symbol(PrimitiveName, Decl(stringLiteralTypesOverloads01.ts, 0, 0)) function getFalsyPrimitive(x: "string"): string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 3, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 2, 27)) function getFalsyPrimitive(x: "number"): number; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 4, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 3, 27)) function getFalsyPrimitive(x: "boolean"): boolean; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 5, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 4, 27)) function getFalsyPrimitive(x: "boolean" | "string"): boolean | string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 6, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 5, 27)) function getFalsyPrimitive(x: "boolean" | "number"): boolean | number; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 7, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 6, 27)) function getFalsyPrimitive(x: "number" | "string"): number | string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 8, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 7, 27)) function getFalsyPrimitive(x: "number" | "string" | "boolean"): number | string | boolean; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 8, 27)) function getFalsyPrimitive(x: PrimitiveName): number | string | boolean { ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) >PrimitiveName : Symbol(PrimitiveName, Decl(stringLiteralTypesOverloads01.ts, 0, 0)) if (x === "string") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) return ""; } if (x === "number") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) return 0; } if (x === "boolean") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27)) return false; } @@ -57,87 +56,87 @@ function getFalsyPrimitive(x: PrimitiveName): number | string | boolean { } namespace Consts1 { ->Consts1 : Symbol(Consts1, Decl(stringLiteralTypesOverloads01.ts, 23, 1)) +>Consts1 : Symbol(Consts1, Decl(stringLiteralTypesOverloads01.ts, 22, 1)) const EMPTY_STRING = getFalsyPrimitive("string"); ->EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 26, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) +>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 25, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) const ZERO = getFalsyPrimitive('number'); ->ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 27, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) +>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 26, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) const FALSE = getFalsyPrimitive("boolean"); ->FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 28, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) +>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 27, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) } const string: "string" = "string" ->string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 30, 5)) const number: "number" = "number" ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) const boolean: "boolean" = "boolean" ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) const stringOrNumber = string || number; ->stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) +>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 34, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 30, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) const stringOrBoolean = string || boolean; ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 30, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) const booleanOrNumber = number || boolean; ->booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5)) +>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) const stringOrBooleanOrNumber = stringOrBoolean || number; ->stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 38, 5)) ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) +>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) namespace Consts2 { ->Consts2 : Symbol(Consts2, Decl(stringLiteralTypesOverloads01.ts, 38, 58)) +>Consts2 : Symbol(Consts2, Decl(stringLiteralTypesOverloads01.ts, 37, 58)) const EMPTY_STRING = getFalsyPrimitive(string); ->EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 41, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) +>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 40, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 30, 5)) const ZERO = getFalsyPrimitive(number); ->ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 42, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) +>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 41, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 31, 5)) const FALSE = getFalsyPrimitive(boolean); ->FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 43, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5)) +>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 42, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 32, 5)) const a = getFalsyPrimitive(stringOrNumber); ->a : Symbol(a, Decl(stringLiteralTypesOverloads01.ts, 45, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) +>a : Symbol(a, Decl(stringLiteralTypesOverloads01.ts, 44, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 34, 5)) const b = getFalsyPrimitive(stringOrBoolean); ->b : Symbol(b, Decl(stringLiteralTypesOverloads01.ts, 46, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) +>b : Symbol(b, Decl(stringLiteralTypesOverloads01.ts, 45, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 35, 5)) const c = getFalsyPrimitive(booleanOrNumber); ->c : Symbol(c, Decl(stringLiteralTypesOverloads01.ts, 47, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5)) +>c : Symbol(c, Decl(stringLiteralTypesOverloads01.ts, 46, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 36, 5)) const d = getFalsyPrimitive(stringOrBooleanOrNumber); ->d : Symbol(d, Decl(stringLiteralTypesOverloads01.ts, 48, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90)) ->stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 38, 5)) +>d : Symbol(d, Decl(stringLiteralTypesOverloads01.ts, 47, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 0, 53), Decl(stringLiteralTypesOverloads01.ts, 2, 48), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 50), Decl(stringLiteralTypesOverloads01.ts, 5, 70), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 68), Decl(stringLiteralTypesOverloads01.ts, 8, 90)) +>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5)) } diff --git a/tests/baselines/reference/stringLiteralTypesOverloads01.types b/tests/baselines/reference/stringLiteralTypesOverloads01.types index 2a0bc61f3e8bb..bceb511294779 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads01.types +++ b/tests/baselines/reference/stringLiteralTypesOverloads01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads01.ts === - type PrimitiveName = 'string' | 'number' | 'boolean'; >PrimitiveName : PrimitiveName diff --git a/tests/baselines/reference/stringLiteralTypesOverloads02.js b/tests/baselines/reference/stringLiteralTypesOverloads02.js index c0a7622075aef..97b635f7dc0c8 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads02.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads02.ts] - function getFalsyPrimitive(x: "string"): string; function getFalsyPrimitive(x: "number"): number; function getFalsyPrimitive(x: "boolean"): boolean; diff --git a/tests/baselines/reference/stringLiteralTypesOverloads02.symbols b/tests/baselines/reference/stringLiteralTypesOverloads02.symbols index 1bbedacf8a5e7..1dee747d64b79 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads02.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloads02.symbols @@ -1,49 +1,48 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads02.ts === - function getFalsyPrimitive(x: "string"): string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 1, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 0, 27)) function getFalsyPrimitive(x: "number"): number; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 2, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 1, 27)) function getFalsyPrimitive(x: "boolean"): boolean; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 3, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 2, 27)) function getFalsyPrimitive(x: "boolean" | "string"): boolean | string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 4, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 3, 27)) function getFalsyPrimitive(x: "boolean" | "number"): boolean | number; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 5, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 4, 27)) function getFalsyPrimitive(x: "number" | "string"): number | string; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 6, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 5, 27)) function getFalsyPrimitive(x: "number" | "string" | "boolean"): number | string | boolean; ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 6, 27)) function getFalsyPrimitive(x: string): string | number | boolean { ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 8, 27)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) if (x === "string") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 8, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) return ""; } if (x === "number") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 8, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) return 0; } if (x === "boolean") { ->x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 8, 27)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads02.ts, 7, 27)) return false; } @@ -53,87 +52,87 @@ function getFalsyPrimitive(x: string): string | number | boolean { } namespace Consts1 { ->Consts1 : Symbol(Consts1, Decl(stringLiteralTypesOverloads02.ts, 21, 1)) +>Consts1 : Symbol(Consts1, Decl(stringLiteralTypesOverloads02.ts, 20, 1)) const EMPTY_STRING = getFalsyPrimitive("string"); ->EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads02.ts, 24, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) +>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads02.ts, 23, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) const ZERO = getFalsyPrimitive('number'); ->ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads02.ts, 25, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) +>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads02.ts, 24, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) const FALSE = getFalsyPrimitive("boolean"); ->FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads02.ts, 26, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) +>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads02.ts, 25, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) } const string = "string" ->string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 28, 5)) const number = "number" ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) const boolean = "boolean" ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 31, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) const stringOrNumber = string || number; ->stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) +>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads02.ts, 32, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 28, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) const stringOrBoolean = string || boolean; ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 31, 5)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 28, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) const booleanOrNumber = number || boolean; ->booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 35, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 31, 5)) +>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) const stringOrBooleanOrNumber = stringOrBoolean || number; ->stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 36, 5)) ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) +>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 35, 5)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) namespace Consts2 { ->Consts2 : Symbol(Consts2, Decl(stringLiteralTypesOverloads02.ts, 36, 58)) +>Consts2 : Symbol(Consts2, Decl(stringLiteralTypesOverloads02.ts, 35, 58)) const EMPTY_STRING = getFalsyPrimitive(string); ->EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads02.ts, 39, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) +>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads02.ts, 38, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>string : Symbol(string, Decl(stringLiteralTypesOverloads02.ts, 28, 5)) const ZERO = getFalsyPrimitive(number); ->ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads02.ts, 40, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) +>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads02.ts, 39, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>number : Symbol(number, Decl(stringLiteralTypesOverloads02.ts, 29, 5)) const FALSE = getFalsyPrimitive(boolean); ->FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads02.ts, 41, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 31, 5)) +>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads02.ts, 40, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads02.ts, 30, 5)) const a = getFalsyPrimitive(stringOrNumber); ->a : Symbol(a, Decl(stringLiteralTypesOverloads02.ts, 43, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) +>a : Symbol(a, Decl(stringLiteralTypesOverloads02.ts, 42, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads02.ts, 32, 5)) const b = getFalsyPrimitive(stringOrBoolean); ->b : Symbol(b, Decl(stringLiteralTypesOverloads02.ts, 44, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) +>b : Symbol(b, Decl(stringLiteralTypesOverloads02.ts, 43, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads02.ts, 33, 5)) const c = getFalsyPrimitive(booleanOrNumber); ->c : Symbol(c, Decl(stringLiteralTypesOverloads02.ts, 45, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 35, 5)) +>c : Symbol(c, Decl(stringLiteralTypesOverloads02.ts, 44, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 34, 5)) const d = getFalsyPrimitive(stringOrBooleanOrNumber); ->d : Symbol(d, Decl(stringLiteralTypesOverloads02.ts, 46, 9)) ->getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 48), Decl(stringLiteralTypesOverloads02.ts, 3, 50), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 70), Decl(stringLiteralTypesOverloads02.ts, 6, 68), Decl(stringLiteralTypesOverloads02.ts, 7, 90)) ->stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 36, 5)) +>d : Symbol(d, Decl(stringLiteralTypesOverloads02.ts, 45, 9)) +>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads02.ts, 0, 0), Decl(stringLiteralTypesOverloads02.ts, 0, 48), Decl(stringLiteralTypesOverloads02.ts, 1, 48), Decl(stringLiteralTypesOverloads02.ts, 2, 50), Decl(stringLiteralTypesOverloads02.ts, 3, 70), Decl(stringLiteralTypesOverloads02.ts, 4, 70), Decl(stringLiteralTypesOverloads02.ts, 5, 68), Decl(stringLiteralTypesOverloads02.ts, 6, 90)) +>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads02.ts, 35, 5)) } diff --git a/tests/baselines/reference/stringLiteralTypesOverloads02.types b/tests/baselines/reference/stringLiteralTypesOverloads02.types index 7122929e85da5..93c3316bc3add 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads02.types +++ b/tests/baselines/reference/stringLiteralTypesOverloads02.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads02.ts === - function getFalsyPrimitive(x: "string"): string; >getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "string" | "boolean"): string | boolean; (x: "number" | "boolean"): number | boolean; (x: "string" | "number"): string | number; (x: "string" | "number" | "boolean"): string | number | boolean; } >x : "string" diff --git a/tests/baselines/reference/stringLiteralTypesOverloads03.js b/tests/baselines/reference/stringLiteralTypesOverloads03.js index 4fdfd4f85d0bd..6aec13ee21ee8 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads03.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads03.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads03.ts] - interface Base { x: string; y: number; diff --git a/tests/baselines/reference/stringLiteralTypesOverloads03.symbols b/tests/baselines/reference/stringLiteralTypesOverloads03.symbols index 277cc7e84e3d1..afcff865a45a8 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads03.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloads03.symbols @@ -1,131 +1,130 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads03.ts === - interface Base { >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) x: string; ->x : Symbol(Base.x, Decl(stringLiteralTypesOverloads03.ts, 1, 16)) +>x : Symbol(Base.x, Decl(stringLiteralTypesOverloads03.ts, 0, 16)) y: number; ->y : Symbol(Base.y, Decl(stringLiteralTypesOverloads03.ts, 2, 14)) +>y : Symbol(Base.y, Decl(stringLiteralTypesOverloads03.ts, 1, 14)) } interface HelloOrWorld extends Base { ->HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 4, 1)) +>HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 3, 1)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) p1: boolean; ->p1 : Symbol(HelloOrWorld.p1, Decl(stringLiteralTypesOverloads03.ts, 6, 37)) +>p1 : Symbol(HelloOrWorld.p1, Decl(stringLiteralTypesOverloads03.ts, 5, 37)) } interface JustHello extends Base { ->JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 8, 1)) +>JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 7, 1)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) p2: boolean; ->p2 : Symbol(JustHello.p2, Decl(stringLiteralTypesOverloads03.ts, 10, 34)) +>p2 : Symbol(JustHello.p2, Decl(stringLiteralTypesOverloads03.ts, 9, 34)) } interface JustWorld extends Base { ->JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 12, 1)) +>JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 11, 1)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) p3: boolean; ->p3 : Symbol(JustWorld.p3, Decl(stringLiteralTypesOverloads03.ts, 14, 34)) +>p3 : Symbol(JustWorld.p3, Decl(stringLiteralTypesOverloads03.ts, 13, 34)) } let hello: "hello"; ->hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) +>hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 17, 3)) let world: "world"; ->world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) +>world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) let helloOrWorld: "hello" | "world"; ->helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 20, 3)) +>helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) function f(p: "hello"): JustHello; ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 22, 11)) ->JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 8, 1)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 21, 11)) +>JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 7, 1)) function f(p: "hello" | "world"): HelloOrWorld; ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 23, 11)) ->HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 4, 1)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 22, 11)) +>HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 3, 1)) function f(p: "world"): JustWorld; ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 24, 11)) ->JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 12, 1)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 23, 11)) +>JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 11, 1)) function f(p: string): Base; ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 25, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 24, 11)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) function f(...args: any[]): any { ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->args : Symbol(args, Decl(stringLiteralTypesOverloads03.ts, 26, 11)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>args : Symbol(args, Decl(stringLiteralTypesOverloads03.ts, 25, 11)) return undefined; >undefined : Symbol(undefined) } let fResult1 = f(hello); ->fResult1 : Symbol(fResult1, Decl(stringLiteralTypesOverloads03.ts, 30, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) +>fResult1 : Symbol(fResult1, Decl(stringLiteralTypesOverloads03.ts, 29, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 17, 3)) let fResult2 = f(world); ->fResult2 : Symbol(fResult2, Decl(stringLiteralTypesOverloads03.ts, 31, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) +>fResult2 : Symbol(fResult2, Decl(stringLiteralTypesOverloads03.ts, 30, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) let fResult3 = f(helloOrWorld); ->fResult3 : Symbol(fResult3, Decl(stringLiteralTypesOverloads03.ts, 32, 3)) ->f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 20, 36), Decl(stringLiteralTypesOverloads03.ts, 22, 34), Decl(stringLiteralTypesOverloads03.ts, 23, 47), Decl(stringLiteralTypesOverloads03.ts, 24, 34), Decl(stringLiteralTypesOverloads03.ts, 25, 28)) ->helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 20, 3)) +>fResult3 : Symbol(fResult3, Decl(stringLiteralTypesOverloads03.ts, 31, 3)) +>f : Symbol(f, Decl(stringLiteralTypesOverloads03.ts, 19, 36), Decl(stringLiteralTypesOverloads03.ts, 21, 34), Decl(stringLiteralTypesOverloads03.ts, 22, 47), Decl(stringLiteralTypesOverloads03.ts, 23, 34), Decl(stringLiteralTypesOverloads03.ts, 24, 28)) +>helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) function g(p: string): Base; ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 34, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 33, 11)) >Base : Symbol(Base, Decl(stringLiteralTypesOverloads03.ts, 0, 0)) function g(p: "hello"): JustHello; ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 35, 11)) ->JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 8, 1)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 34, 11)) +>JustHello : Symbol(JustHello, Decl(stringLiteralTypesOverloads03.ts, 7, 1)) function g(p: "hello" | "world"): HelloOrWorld; ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 36, 11)) ->HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 4, 1)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 35, 11)) +>HelloOrWorld : Symbol(HelloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 3, 1)) function g(p: "world"): JustWorld; ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 37, 11)) ->JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 12, 1)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads03.ts, 36, 11)) +>JustWorld : Symbol(JustWorld, Decl(stringLiteralTypesOverloads03.ts, 11, 1)) function g(...args: any[]): any { ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->args : Symbol(args, Decl(stringLiteralTypesOverloads03.ts, 38, 11)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>args : Symbol(args, Decl(stringLiteralTypesOverloads03.ts, 37, 11)) return undefined; >undefined : Symbol(undefined) } let gResult1 = g(hello); ->gResult1 : Symbol(gResult1, Decl(stringLiteralTypesOverloads03.ts, 42, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) +>gResult1 : Symbol(gResult1, Decl(stringLiteralTypesOverloads03.ts, 41, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>hello : Symbol(hello, Decl(stringLiteralTypesOverloads03.ts, 17, 3)) let gResult2 = g(world); ->gResult2 : Symbol(gResult2, Decl(stringLiteralTypesOverloads03.ts, 43, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) +>gResult2 : Symbol(gResult2, Decl(stringLiteralTypesOverloads03.ts, 42, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>world : Symbol(world, Decl(stringLiteralTypesOverloads03.ts, 18, 3)) let gResult3 = g(helloOrWorld); ->gResult3 : Symbol(gResult3, Decl(stringLiteralTypesOverloads03.ts, 44, 3)) ->g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 32, 31), Decl(stringLiteralTypesOverloads03.ts, 34, 28), Decl(stringLiteralTypesOverloads03.ts, 35, 34), Decl(stringLiteralTypesOverloads03.ts, 36, 47), Decl(stringLiteralTypesOverloads03.ts, 37, 34)) ->helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 20, 3)) +>gResult3 : Symbol(gResult3, Decl(stringLiteralTypesOverloads03.ts, 43, 3)) +>g : Symbol(g, Decl(stringLiteralTypesOverloads03.ts, 31, 31), Decl(stringLiteralTypesOverloads03.ts, 33, 28), Decl(stringLiteralTypesOverloads03.ts, 34, 34), Decl(stringLiteralTypesOverloads03.ts, 35, 47), Decl(stringLiteralTypesOverloads03.ts, 36, 34)) +>helloOrWorld : Symbol(helloOrWorld, Decl(stringLiteralTypesOverloads03.ts, 19, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesOverloads03.types b/tests/baselines/reference/stringLiteralTypesOverloads03.types index 643979ee987ca..8fcf1745f2a44 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads03.types +++ b/tests/baselines/reference/stringLiteralTypesOverloads03.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads03.ts === - interface Base { >Base : Base diff --git a/tests/baselines/reference/stringLiteralTypesOverloads04.js b/tests/baselines/reference/stringLiteralTypesOverloads04.js index 81e123c3e57b3..4d16d072fa571 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads04.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads04.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads04.ts] - declare function f(x: (p: "foo" | "bar") => "foo"); f(y => { diff --git a/tests/baselines/reference/stringLiteralTypesOverloads04.symbols b/tests/baselines/reference/stringLiteralTypesOverloads04.symbols index de1951d325a95..57398948aa87b 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads04.symbols +++ b/tests/baselines/reference/stringLiteralTypesOverloads04.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads04.ts === - declare function f(x: (p: "foo" | "bar") => "foo"); >f : Symbol(f, Decl(stringLiteralTypesOverloads04.ts, 0, 0)) ->x : Symbol(x, Decl(stringLiteralTypesOverloads04.ts, 1, 19)) ->p : Symbol(p, Decl(stringLiteralTypesOverloads04.ts, 1, 23)) +>x : Symbol(x, Decl(stringLiteralTypesOverloads04.ts, 0, 19)) +>p : Symbol(p, Decl(stringLiteralTypesOverloads04.ts, 0, 23)) f(y => { >f : Symbol(f, Decl(stringLiteralTypesOverloads04.ts, 0, 0)) ->y : Symbol(y, Decl(stringLiteralTypesOverloads04.ts, 3, 2)) +>y : Symbol(y, Decl(stringLiteralTypesOverloads04.ts, 2, 2)) const z = y = "foo"; ->z : Symbol(z, Decl(stringLiteralTypesOverloads04.ts, 4, 9)) ->y : Symbol(y, Decl(stringLiteralTypesOverloads04.ts, 3, 2)) +>z : Symbol(z, Decl(stringLiteralTypesOverloads04.ts, 3, 9)) +>y : Symbol(y, Decl(stringLiteralTypesOverloads04.ts, 2, 2)) return z; ->z : Symbol(z, Decl(stringLiteralTypesOverloads04.ts, 4, 9)) +>z : Symbol(z, Decl(stringLiteralTypesOverloads04.ts, 3, 9)) }) diff --git a/tests/baselines/reference/stringLiteralTypesOverloads04.types b/tests/baselines/reference/stringLiteralTypesOverloads04.types index 8cb8b2a7ceab2..a68d9ddf9a5a2 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads04.types +++ b/tests/baselines/reference/stringLiteralTypesOverloads04.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads04.ts === - declare function f(x: (p: "foo" | "bar") => "foo"); >f : (x: (p: "foo" | "bar") => "foo") => any >x : (p: "foo" | "bar") => "foo" diff --git a/tests/baselines/reference/stringLiteralTypesOverloads05.errors.txt b/tests/baselines/reference/stringLiteralTypesOverloads05.errors.txt index e57327ab0e01b..027feb7cc31a6 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads05.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesOverloads05.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads05.ts(7,10): error TS2394: Overload signature is not compatible with function implementation. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads05.ts(6,10): error TS2394: Overload signature is not compatible with function implementation. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads05.ts (1 errors) ==== - interface Animal { animal: {} }; interface Dog extends Animal { dog: {} } interface Cat extends Animal { cat: {} } diff --git a/tests/baselines/reference/stringLiteralTypesOverloads05.js b/tests/baselines/reference/stringLiteralTypesOverloads05.js index 23be3dac1e1b2..7848a57819a8b 100644 --- a/tests/baselines/reference/stringLiteralTypesOverloads05.js +++ b/tests/baselines/reference/stringLiteralTypesOverloads05.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesOverloads05.ts] - interface Animal { animal: {} }; interface Dog extends Animal { dog: {} } interface Cat extends Animal { cat: {} } diff --git a/tests/baselines/reference/stringLiteralTypesTypePredicates01.js b/tests/baselines/reference/stringLiteralTypesTypePredicates01.js index fdd03c83aa5b0..cf22198f48d35 100644 --- a/tests/baselines/reference/stringLiteralTypesTypePredicates01.js +++ b/tests/baselines/reference/stringLiteralTypesTypePredicates01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesTypePredicates01.ts] - type Kind = "A" | "B" function kindIs(kind: Kind, is: "A"): kind is "A"; diff --git a/tests/baselines/reference/stringLiteralTypesTypePredicates01.symbols b/tests/baselines/reference/stringLiteralTypesTypePredicates01.symbols index aea8c6ac262b2..42b1e78703af6 100644 --- a/tests/baselines/reference/stringLiteralTypesTypePredicates01.symbols +++ b/tests/baselines/reference/stringLiteralTypesTypePredicates01.symbols @@ -1,63 +1,62 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesTypePredicates01.ts === - type Kind = "A" | "B" >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) function kindIs(kind: Kind, is: "A"): kind is "A"; ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) +>kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 2, 16)) +>Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) +>is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 2, 27)) +>kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 2, 16)) + +function kindIs(kind: Kind, is: "B"): kind is "B"; +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) >kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 3, 16)) >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) >is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 3, 27)) >kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 3, 16)) -function kindIs(kind: Kind, is: "B"): kind is "B"; ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) +function kindIs(kind: Kind, is: Kind): boolean { +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) >kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 4, 16)) >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) >is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 4, 27)) ->kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 4, 16)) - -function kindIs(kind: Kind, is: Kind): boolean { ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) ->kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 5, 16)) ->Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) ->is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 5, 27)) >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) return kind === is; ->kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 5, 16)) ->is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 5, 27)) +>kind : Symbol(kind, Decl(stringLiteralTypesTypePredicates01.ts, 4, 16)) +>is : Symbol(is, Decl(stringLiteralTypesTypePredicates01.ts, 4, 27)) } var x: Kind = undefined; ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) >Kind : Symbol(Kind, Decl(stringLiteralTypesTypePredicates01.ts, 0, 0)) >undefined : Symbol(undefined) if (kindIs(x, "A")) { ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) let a = x; ->a : Symbol(a, Decl(stringLiteralTypesTypePredicates01.ts, 12, 7)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>a : Symbol(a, Decl(stringLiteralTypesTypePredicates01.ts, 11, 7)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) } else { let b = x; ->b : Symbol(b, Decl(stringLiteralTypesTypePredicates01.ts, 15, 7)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>b : Symbol(b, Decl(stringLiteralTypesTypePredicates01.ts, 14, 7)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) } if (!kindIs(x, "B")) { ->kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 1, 21), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50), Decl(stringLiteralTypesTypePredicates01.ts, 4, 50)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>kindIs : Symbol(kindIs, Decl(stringLiteralTypesTypePredicates01.ts, 0, 21), Decl(stringLiteralTypesTypePredicates01.ts, 2, 50), Decl(stringLiteralTypesTypePredicates01.ts, 3, 50)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) let c = x; ->c : Symbol(c, Decl(stringLiteralTypesTypePredicates01.ts, 19, 7)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>c : Symbol(c, Decl(stringLiteralTypesTypePredicates01.ts, 18, 7)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) } else { let d = x; ->d : Symbol(d, Decl(stringLiteralTypesTypePredicates01.ts, 22, 7)) ->x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 9, 3)) +>d : Symbol(d, Decl(stringLiteralTypesTypePredicates01.ts, 21, 7)) +>x : Symbol(x, Decl(stringLiteralTypesTypePredicates01.ts, 8, 3)) } diff --git a/tests/baselines/reference/stringLiteralTypesTypePredicates01.types b/tests/baselines/reference/stringLiteralTypesTypePredicates01.types index 822103b86f571..ab5c40ae6203a 100644 --- a/tests/baselines/reference/stringLiteralTypesTypePredicates01.types +++ b/tests/baselines/reference/stringLiteralTypesTypePredicates01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesTypePredicates01.ts === - type Kind = "A" | "B" >Kind : Kind diff --git a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.errors.txt b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.errors.txt index 3851a0b10efaa..a1819ddb82f72 100644 --- a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.errors.txt @@ -1,10 +1,9 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(2,5): error TS2322: Type 'string' is not assignable to type '"ABC"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(3,5): error TS2322: Type 'string' is not assignable to type '"DE\nF"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(6,5): error TS2322: Type 'string' is not assignable to type '"JK`L"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(1,5): error TS2322: Type 'string' is not assignable to type '"ABC"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(2,5): error TS2322: Type 'string' is not assignable to type '"DE\nF"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts(5,5): error TS2322: Type 'string' is not assignable to type '"JK`L"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings01.ts (3 errors) ==== - let ABC: "ABC" = `ABC`; ~~~ !!! error TS2322: Type 'string' is not assignable to type '"ABC"'. diff --git a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.js b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.js index 8f548afc7bf19..f1833b55c20f7 100644 --- a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.js +++ b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesWithTemplateStrings01.ts] - let ABC: "ABC" = `ABC`; let DE_NEWLINE_F: "DE\nF" = `DE F`; diff --git a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.errors.txt b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.errors.txt index 803e4f5cb24e7..8c69e595e255a 100644 --- a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts(2,5): error TS2322: Type 'string' is not assignable to type '"AB\r\nC"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts(4,5): error TS2322: Type 'string' is not assignable to type '"DE\nF"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts(1,5): error TS2322: Type 'string' is not assignable to type '"AB\r\nC"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts(3,5): error TS2322: Type 'string' is not assignable to type '"DE\nF"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithTemplateStrings02.ts (2 errors) ==== - let abc: "AB\r\nC" = `AB ~~~ !!! error TS2322: Type 'string' is not assignable to type '"AB\r\nC"'. diff --git a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.js b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.js index f5d9045921a8e..8d675eeb9c40d 100644 --- a/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.js +++ b/tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesWithTemplateStrings02.ts] - let abc: "AB\r\nC" = `AB C`; let de_NEWLINE_f: "DE\nF" = `DE${"\n"}F`; diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.js b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.js index 1576540e24446..08c3f4aa4b752 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.js +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesWithVariousOperators01.ts] - let abc: "ABC" = "ABC"; let xyz: "XYZ" = "XYZ"; let abcOrXyz: "ABC" | "XYZ" = abc || xyz; diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.symbols b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.symbols index cc9c3aa842bd3..b226c964143ea 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.symbols +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.symbols @@ -1,116 +1,115 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators01.ts === - let abc: "ABC" = "ABC"; ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let xyz: "XYZ" = "XYZ"; ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) let abcOrXyz: "ABC" | "XYZ" = abc || xyz; ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) let abcOrXyzOrNumber: "ABC" | "XYZ" | number = abcOrXyz || 100; ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let a = "" + abc; ->a : Symbol(a, Decl(stringLiteralTypesWithVariousOperators01.ts, 6, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>a : Symbol(a, Decl(stringLiteralTypesWithVariousOperators01.ts, 5, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let b = abc + ""; ->b : Symbol(b, Decl(stringLiteralTypesWithVariousOperators01.ts, 7, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>b : Symbol(b, Decl(stringLiteralTypesWithVariousOperators01.ts, 6, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let c = 10 + abc; ->c : Symbol(c, Decl(stringLiteralTypesWithVariousOperators01.ts, 8, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>c : Symbol(c, Decl(stringLiteralTypesWithVariousOperators01.ts, 7, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let d = abc + 10; ->d : Symbol(d, Decl(stringLiteralTypesWithVariousOperators01.ts, 9, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>d : Symbol(d, Decl(stringLiteralTypesWithVariousOperators01.ts, 8, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let e = xyz + abc; ->e : Symbol(e, Decl(stringLiteralTypesWithVariousOperators01.ts, 10, 3)) ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>e : Symbol(e, Decl(stringLiteralTypesWithVariousOperators01.ts, 9, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let f = abc + xyz; ->f : Symbol(f, Decl(stringLiteralTypesWithVariousOperators01.ts, 11, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>f : Symbol(f, Decl(stringLiteralTypesWithVariousOperators01.ts, 10, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) let g = true + abc; ->g : Symbol(g, Decl(stringLiteralTypesWithVariousOperators01.ts, 12, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>g : Symbol(g, Decl(stringLiteralTypesWithVariousOperators01.ts, 11, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let h = abc + true; ->h : Symbol(h, Decl(stringLiteralTypesWithVariousOperators01.ts, 13, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) +>h : Symbol(h, Decl(stringLiteralTypesWithVariousOperators01.ts, 12, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) let i = abc + abcOrXyz + xyz; ->i : Symbol(i, Decl(stringLiteralTypesWithVariousOperators01.ts, 14, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>i : Symbol(i, Decl(stringLiteralTypesWithVariousOperators01.ts, 13, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>xyz : Symbol(xyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) let j = abcOrXyz + abcOrXyz; ->j : Symbol(j, Decl(stringLiteralTypesWithVariousOperators01.ts, 15, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>j : Symbol(j, Decl(stringLiteralTypesWithVariousOperators01.ts, 14, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let k = +abcOrXyz; ->k : Symbol(k, Decl(stringLiteralTypesWithVariousOperators01.ts, 16, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>k : Symbol(k, Decl(stringLiteralTypesWithVariousOperators01.ts, 15, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let l = -abcOrXyz; ->l : Symbol(l, Decl(stringLiteralTypesWithVariousOperators01.ts, 17, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>l : Symbol(l, Decl(stringLiteralTypesWithVariousOperators01.ts, 16, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let m = abcOrXyzOrNumber + ""; ->m : Symbol(m, Decl(stringLiteralTypesWithVariousOperators01.ts, 18, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>m : Symbol(m, Decl(stringLiteralTypesWithVariousOperators01.ts, 17, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let n = "" + abcOrXyzOrNumber; ->n : Symbol(n, Decl(stringLiteralTypesWithVariousOperators01.ts, 19, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>n : Symbol(n, Decl(stringLiteralTypesWithVariousOperators01.ts, 18, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let o = abcOrXyzOrNumber + abcOrXyz; ->o : Symbol(o, Decl(stringLiteralTypesWithVariousOperators01.ts, 20, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>o : Symbol(o, Decl(stringLiteralTypesWithVariousOperators01.ts, 19, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let p = abcOrXyz + abcOrXyzOrNumber; ->p : Symbol(p, Decl(stringLiteralTypesWithVariousOperators01.ts, 21, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>p : Symbol(p, Decl(stringLiteralTypesWithVariousOperators01.ts, 20, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let q = !abcOrXyzOrNumber; ->q : Symbol(q, Decl(stringLiteralTypesWithVariousOperators01.ts, 22, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>q : Symbol(q, Decl(stringLiteralTypesWithVariousOperators01.ts, 21, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let r = ~abcOrXyzOrNumber; ->r : Symbol(r, Decl(stringLiteralTypesWithVariousOperators01.ts, 23, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>r : Symbol(r, Decl(stringLiteralTypesWithVariousOperators01.ts, 22, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let s = abcOrXyzOrNumber < abcOrXyzOrNumber; ->s : Symbol(s, Decl(stringLiteralTypesWithVariousOperators01.ts, 24, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>s : Symbol(s, Decl(stringLiteralTypesWithVariousOperators01.ts, 23, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) let t = abcOrXyzOrNumber >= abcOrXyz; ->t : Symbol(t, Decl(stringLiteralTypesWithVariousOperators01.ts, 25, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>t : Symbol(t, Decl(stringLiteralTypesWithVariousOperators01.ts, 24, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let u = abc === abcOrXyz; ->u : Symbol(u, Decl(stringLiteralTypesWithVariousOperators01.ts, 26, 3)) ->abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 1, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) +>u : Symbol(u, Decl(stringLiteralTypesWithVariousOperators01.ts, 25, 3)) +>abc : Symbol(abc, Decl(stringLiteralTypesWithVariousOperators01.ts, 0, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) let v = abcOrXyz === abcOrXyzOrNumber; ->v : Symbol(v, Decl(stringLiteralTypesWithVariousOperators01.ts, 27, 3)) ->abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) ->abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 4, 3)) +>v : Symbol(v, Decl(stringLiteralTypesWithVariousOperators01.ts, 26, 3)) +>abcOrXyz : Symbol(abcOrXyz, Decl(stringLiteralTypesWithVariousOperators01.ts, 2, 3)) +>abcOrXyzOrNumber : Symbol(abcOrXyzOrNumber, Decl(stringLiteralTypesWithVariousOperators01.ts, 3, 3)) diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.types b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.types index 46dfef010a0a0..4241ca267f60a 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.types +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators01.ts === - let abc: "ABC" = "ABC"; >abc : "ABC" >"ABC" : "ABC" diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.errors.txt b/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.errors.txt index a4944f7f16304..03fa065fcd3b6 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.errors.txt +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.errors.txt @@ -1,18 +1,17 @@ -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(7,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and '100'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(8,9): error TS2365: Operator '+' cannot be applied to types '100' and 'number | "ABC" | "XYZ"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(9,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and 'number | "ABC" | "XYZ"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(10,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and 'true'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(11,9): error TS2365: Operator '+' cannot be applied to types 'false' and 'number | "ABC" | "XYZ"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(12,9): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(13,11): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(6,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and '100'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(7,9): error TS2365: Operator '+' cannot be applied to types '100' and 'number | "ABC" | "XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(8,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and 'number | "ABC" | "XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(9,9): error TS2365: Operator '+' cannot be applied to types 'number | "ABC" | "XYZ"' and 'true'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(10,9): error TS2365: Operator '+' cannot be applied to types 'false' and 'number | "ABC" | "XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(11,9): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(12,11): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(13,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(14,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(15,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(17,9): error TS2365: Operator '===' cannot be applied to types '"ABC"' and '"XYZ"'. -tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(18,9): error TS2365: Operator '!=' cannot be applied to types '"ABC"' and '"XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(16,9): error TS2365: Operator '===' cannot be applied to types '"ABC"' and '"XYZ"'. +tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts(17,9): error TS2365: Operator '!=' cannot be applied to types '"ABC"' and '"XYZ"'. ==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesWithVariousOperators02.ts (11 errors) ==== - let abc: "ABC" = "ABC"; let xyz: "XYZ" = "XYZ"; let abcOrXyz: "ABC" | "XYZ" = abc || xyz; diff --git a/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.js b/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.js index 4914ecf3d178a..fe64c263af60c 100644 --- a/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.js +++ b/tests/baselines/reference/stringLiteralTypesWithVariousOperators02.js @@ -1,5 +1,4 @@ //// [stringLiteralTypesWithVariousOperators02.ts] - let abc: "ABC" = "ABC"; let xyz: "XYZ" = "XYZ"; let abcOrXyz: "ABC" | "XYZ" = abc || xyz; diff --git a/tests/baselines/reference/stripInternal1.js b/tests/baselines/reference/stripInternal1.js index e5fbe40df7ab7..475904906f01e 100644 --- a/tests/baselines/reference/stripInternal1.js +++ b/tests/baselines/reference/stripInternal1.js @@ -1,5 +1,4 @@ //// [stripInternal1.ts] - class C { foo(): void { } // @internal diff --git a/tests/baselines/reference/stripInternal1.symbols b/tests/baselines/reference/stripInternal1.symbols index dd53f671bc916..d49d838780874 100644 --- a/tests/baselines/reference/stripInternal1.symbols +++ b/tests/baselines/reference/stripInternal1.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/stripInternal1.ts === - class C { >C : Symbol(C, Decl(stripInternal1.ts, 0, 0)) foo(): void { } ->foo : Symbol(C.foo, Decl(stripInternal1.ts, 1, 9)) +>foo : Symbol(C.foo, Decl(stripInternal1.ts, 0, 9)) // @internal bar(): void { } ->bar : Symbol(C.bar, Decl(stripInternal1.ts, 2, 17)) +>bar : Symbol(C.bar, Decl(stripInternal1.ts, 1, 17)) } diff --git a/tests/baselines/reference/stripInternal1.types b/tests/baselines/reference/stripInternal1.types index 8452de4559677..49c2d420477cf 100644 --- a/tests/baselines/reference/stripInternal1.types +++ b/tests/baselines/reference/stripInternal1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/stripInternal1.ts === - class C { >C : C diff --git a/tests/baselines/reference/structuralTypeInDeclareFileForModule.js b/tests/baselines/reference/structuralTypeInDeclareFileForModule.js index b7d5615d3ffeb..c7577432b760f 100644 --- a/tests/baselines/reference/structuralTypeInDeclareFileForModule.js +++ b/tests/baselines/reference/structuralTypeInDeclareFileForModule.js @@ -1,5 +1,4 @@ //// [structuralTypeInDeclareFileForModule.ts] - module M { export var x; } var m = M; diff --git a/tests/baselines/reference/structuralTypeInDeclareFileForModule.symbols b/tests/baselines/reference/structuralTypeInDeclareFileForModule.symbols index 93aa04ba6bbfe..c28a454e2667b 100644 --- a/tests/baselines/reference/structuralTypeInDeclareFileForModule.symbols +++ b/tests/baselines/reference/structuralTypeInDeclareFileForModule.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/structuralTypeInDeclareFileForModule.ts === - module M { export var x; } >M : Symbol(M, Decl(structuralTypeInDeclareFileForModule.ts, 0, 0)) ->x : Symbol(x, Decl(structuralTypeInDeclareFileForModule.ts, 1, 21)) +>x : Symbol(x, Decl(structuralTypeInDeclareFileForModule.ts, 0, 21)) var m = M; ->m : Symbol(m, Decl(structuralTypeInDeclareFileForModule.ts, 2, 3)) +>m : Symbol(m, Decl(structuralTypeInDeclareFileForModule.ts, 1, 3)) >M : Symbol(M, Decl(structuralTypeInDeclareFileForModule.ts, 0, 0)) diff --git a/tests/baselines/reference/structuralTypeInDeclareFileForModule.types b/tests/baselines/reference/structuralTypeInDeclareFileForModule.types index ff023a7913335..4fd3b51643bb8 100644 --- a/tests/baselines/reference/structuralTypeInDeclareFileForModule.types +++ b/tests/baselines/reference/structuralTypeInDeclareFileForModule.types @@ -1,5 +1,4 @@ === tests/cases/compiler/structuralTypeInDeclareFileForModule.ts === - module M { export var x; } >M : typeof M >x : any diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt index f491cac9f0c70..f4d6a4c4e5d8e 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts(8,17): error TS2314: Generic type 'A' requires 2 type argument(s). +tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts(7,17): error TS2314: Generic type 'A' requires 2 type argument(s). ==== tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts (1 errors) ==== - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js index 1803820712557..a80ea5c047d7d 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js @@ -1,5 +1,4 @@ //// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt index 32047f3b41719..3bf76b099e862 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts(8,17): error TS2314: Generic type 'A' requires 2 type argument(s). +tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts(7,17): error TS2314: Generic type 'A' requires 2 type argument(s). ==== tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts (1 errors) ==== - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js index 77b0f4af212e7..c73e6d6cb44f4 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js @@ -1,5 +1,4 @@ //// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt index 4aa9e5a134b29..6b3390493c456 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt +++ b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts(8,17): error TS2315: Type 'A' is not generic. +tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts(7,17): error TS2315: Type 'A' is not generic. ==== tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts (1 errors) ==== - class A { constructor(private map: (value: number) => string) { diff --git a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js index 861bd9b470cb5..8c345104e287b 100644 --- a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js +++ b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js @@ -1,5 +1,4 @@ //// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts] - class A { constructor(private map: (value: number) => string) { diff --git a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt index bac5abad00467..99889e3ed0396 100644 --- a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt +++ b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts(9,21): error TS2335: 'super' can only be referenced in a derived class. +tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts(8,21): error TS2335: 'super' can only be referenced in a derived class. ==== tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts (1 errors) ==== - class A { constructor(private map: (value: number) => string) { diff --git a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js index e4b358c9a0a61..33cbede2ab277 100644 --- a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js +++ b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js @@ -1,5 +1,4 @@ //// [superCallFromClassThatHasNoBaseType1.ts] - class A { constructor(private map: (value: number) => string) { diff --git a/tests/baselines/reference/superCallFromFunction1.errors.txt b/tests/baselines/reference/superCallFromFunction1.errors.txt index b993d9f12536b..4c5c58c1d8c39 100644 --- a/tests/baselines/reference/superCallFromFunction1.errors.txt +++ b/tests/baselines/reference/superCallFromFunction1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/superCallFromFunction1.ts(3,5): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/compiler/superCallFromFunction1.ts(2,5): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. ==== tests/cases/compiler/superCallFromFunction1.ts (1 errors) ==== - function foo() { super(value => String(value)); ~~~~~ diff --git a/tests/baselines/reference/superCallFromFunction1.js b/tests/baselines/reference/superCallFromFunction1.js index 7f34628c58a89..308c0de6524fe 100644 --- a/tests/baselines/reference/superCallFromFunction1.js +++ b/tests/baselines/reference/superCallFromFunction1.js @@ -1,5 +1,4 @@ //// [superCallFromFunction1.ts] - function foo() { super(value => String(value)); } diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.js b/tests/baselines/reference/superCallParameterContextualTyping1.js index cfb0efa9d3de0..c846a029c917f 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping1.js +++ b/tests/baselines/reference/superCallParameterContextualTyping1.js @@ -1,5 +1,4 @@ //// [superCallParameterContextualTyping1.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.symbols b/tests/baselines/reference/superCallParameterContextualTyping1.symbols index 91eff4b3c8b3d..628234537e2a5 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping1.symbols +++ b/tests/baselines/reference/superCallParameterContextualTyping1.symbols @@ -1,30 +1,29 @@ === tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping1.ts === - class A { >A : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0)) ->T1 : Symbol(T1, Decl(superCallParameterContextualTyping1.ts, 1, 8)) ->T2 : Symbol(T2, Decl(superCallParameterContextualTyping1.ts, 1, 11)) +>T1 : Symbol(T1, Decl(superCallParameterContextualTyping1.ts, 0, 8)) +>T2 : Symbol(T2, Decl(superCallParameterContextualTyping1.ts, 0, 11)) constructor(private map: (value: T1) => T2) { ->map : Symbol(A.map, Decl(superCallParameterContextualTyping1.ts, 2, 16)) ->value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 2, 30)) ->T1 : Symbol(T1, Decl(superCallParameterContextualTyping1.ts, 1, 8)) ->T2 : Symbol(T2, Decl(superCallParameterContextualTyping1.ts, 1, 11)) +>map : Symbol(A.map, Decl(superCallParameterContextualTyping1.ts, 1, 16)) +>value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 1, 30)) +>T1 : Symbol(T1, Decl(superCallParameterContextualTyping1.ts, 0, 8)) +>T2 : Symbol(T2, Decl(superCallParameterContextualTyping1.ts, 0, 11)) } } class B extends A { ->B : Symbol(B, Decl(superCallParameterContextualTyping1.ts, 5, 1)) +>B : Symbol(B, Decl(superCallParameterContextualTyping1.ts, 4, 1)) >A : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0)) // Ensure 'value' is of type 'number (and not '{}') by using its 'toExponential()' method. constructor() { super(value => String(value.toExponential())); } >super : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0)) ->value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 9, 26)) +>value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 8, 26)) >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >value.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) ->value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 9, 26)) +>value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 8, 26)) >toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.types b/tests/baselines/reference/superCallParameterContextualTyping1.types index 4dc68fee3f7cc..edba3ee3d3a38 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping1.types +++ b/tests/baselines/reference/superCallParameterContextualTyping1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping1.ts === - class A { >A : A >T1 : T1 diff --git a/tests/baselines/reference/superCallParameterContextualTyping2.errors.txt b/tests/baselines/reference/superCallParameterContextualTyping2.errors.txt index 92451ffd056a4..040f6c6435c1f 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping2.errors.txt +++ b/tests/baselines/reference/superCallParameterContextualTyping2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping2.ts(10,43): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type 'Number' has no compatible call signatures. +tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping2.ts(9,43): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type 'Number' has no compatible call signatures. ==== tests/cases/conformance/expressions/contextualTyping/superCallParameterContextualTyping2.ts (1 errors) ==== - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superCallParameterContextualTyping2.js b/tests/baselines/reference/superCallParameterContextualTyping2.js index f1180347142ff..7cd480d1b6529 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping2.js +++ b/tests/baselines/reference/superCallParameterContextualTyping2.js @@ -1,5 +1,4 @@ //// [superCallParameterContextualTyping2.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superNewCall1.errors.txt b/tests/baselines/reference/superNewCall1.errors.txt index c8fd5c471fbf6..3ec370518c481 100644 --- a/tests/baselines/reference/superNewCall1.errors.txt +++ b/tests/baselines/reference/superNewCall1.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/superNewCall1.ts(9,5): error TS2377: Constructors for derived classes must contain a 'super' call. -tests/cases/compiler/superNewCall1.ts(10,9): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature. -tests/cases/compiler/superNewCall1.ts(10,13): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. +tests/cases/compiler/superNewCall1.ts(8,5): error TS2377: Constructors for derived classes must contain a 'super' call. +tests/cases/compiler/superNewCall1.ts(9,9): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature. +tests/cases/compiler/superNewCall1.ts(9,13): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. ==== tests/cases/compiler/superNewCall1.ts (3 errors) ==== - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superNewCall1.js b/tests/baselines/reference/superNewCall1.js index a7a94deb6dc19..687f0847fa92d 100644 --- a/tests/baselines/reference/superNewCall1.js +++ b/tests/baselines/reference/superNewCall1.js @@ -1,5 +1,4 @@ //// [superNewCall1.ts] - class A { constructor(private map: (value: T1) => T2) { diff --git a/tests/baselines/reference/superPropertyAccess.errors.txt b/tests/baselines/reference/superPropertyAccess.errors.txt index 22b1a1c534662..e1b813453900c 100644 --- a/tests/baselines/reference/superPropertyAccess.errors.txt +++ b/tests/baselines/reference/superPropertyAccess.errors.txt @@ -1,15 +1,14 @@ +tests/cases/compiler/superPropertyAccess.ts(7,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/compiler/superPropertyAccess.ts(8,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/superPropertyAccess.ts(9,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/superPropertyAccess.ts(22,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess.ts(24,15): error TS2341: Property 'p1' is private and only accessible within class 'MyBase'. -tests/cases/compiler/superPropertyAccess.ts(26,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess.ts(28,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess.ts(32,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess.ts(34,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(21,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(23,15): error TS2341: Property 'p1' is private and only accessible within class 'MyBase'. +tests/cases/compiler/superPropertyAccess.ts(25,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(27,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(31,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(33,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/compiler/superPropertyAccess.ts (8 errors) ==== - class MyBase { m1(a: string) { return a; } private p1() { } diff --git a/tests/baselines/reference/superPropertyAccess.js b/tests/baselines/reference/superPropertyAccess.js index 342e39b9885d4..d84bb5c08b829 100644 --- a/tests/baselines/reference/superPropertyAccess.js +++ b/tests/baselines/reference/superPropertyAccess.js @@ -1,5 +1,4 @@ //// [superPropertyAccess.ts] - class MyBase { m1(a: string) { return a; } private p1() { } diff --git a/tests/baselines/reference/superPropertyAccess_ES5.errors.txt b/tests/baselines/reference/superPropertyAccess_ES5.errors.txt index 08adcd36e6829..071cfd2372777 100644 --- a/tests/baselines/reference/superPropertyAccess_ES5.errors.txt +++ b/tests/baselines/reference/superPropertyAccess_ES5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/superPropertyAccess_ES5.ts(12,22): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/compiler/superPropertyAccess_ES5.ts(27,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess_ES5.ts(11,22): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess_ES5.ts(26,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/compiler/superPropertyAccess_ES5.ts (2 errors) ==== - class MyBase { getValue(): number { return 1; } get value(): number { return 1; } diff --git a/tests/baselines/reference/superPropertyAccess_ES5.js b/tests/baselines/reference/superPropertyAccess_ES5.js index 1b74519464aa5..406fa087a4440 100644 --- a/tests/baselines/reference/superPropertyAccess_ES5.js +++ b/tests/baselines/reference/superPropertyAccess_ES5.js @@ -1,5 +1,4 @@ //// [superPropertyAccess_ES5.ts] - class MyBase { getValue(): number { return 1; } get value(): number { return 1; } diff --git a/tests/baselines/reference/superPropertyAccess_ES6.js b/tests/baselines/reference/superPropertyAccess_ES6.js index 1b23c6ca0d89c..58022fd9e3d7a 100644 --- a/tests/baselines/reference/superPropertyAccess_ES6.js +++ b/tests/baselines/reference/superPropertyAccess_ES6.js @@ -1,5 +1,4 @@ //// [superPropertyAccess_ES6.ts] - class MyBase { getValue(): number { return 1; } get value(): number { return 1; } diff --git a/tests/baselines/reference/superPropertyAccess_ES6.symbols b/tests/baselines/reference/superPropertyAccess_ES6.symbols index 61b8ab3dc76d3..da2216f591ca5 100644 --- a/tests/baselines/reference/superPropertyAccess_ES6.symbols +++ b/tests/baselines/reference/superPropertyAccess_ES6.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/superPropertyAccess_ES6.ts === - class MyBase { >MyBase : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) getValue(): number { return 1; } ->getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 1, 14)) +>getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 0, 14)) get value(): number { return 1; } ->value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) +>value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) } class MyDerived extends MyBase { ->MyDerived : Symbol(MyDerived, Decl(superPropertyAccess_ES6.ts, 4, 1)) +>MyDerived : Symbol(MyDerived, Decl(superPropertyAccess_ES6.ts, 3, 1)) >MyBase : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) constructor() { @@ -19,62 +18,62 @@ class MyDerived extends MyBase { >super : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) const f1 = super.getValue(); ->f1 : Symbol(f1, Decl(superPropertyAccess_ES6.ts, 10, 9)) ->super.getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 1, 14)) +>f1 : Symbol(f1, Decl(superPropertyAccess_ES6.ts, 9, 9)) +>super.getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 0, 14)) >super : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) ->getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 1, 14)) +>getValue : Symbol(MyBase.getValue, Decl(superPropertyAccess_ES6.ts, 0, 14)) const f2 = super.value; ->f2 : Symbol(f2, Decl(superPropertyAccess_ES6.ts, 11, 9)) ->super.value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) +>f2 : Symbol(f2, Decl(superPropertyAccess_ES6.ts, 10, 9)) +>super.value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) >super : Symbol(MyBase, Decl(superPropertyAccess_ES6.ts, 0, 0)) ->value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) +>value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) } } var d = new MyDerived(); ->d : Symbol(d, Decl(superPropertyAccess_ES6.ts, 15, 3)) ->MyDerived : Symbol(MyDerived, Decl(superPropertyAccess_ES6.ts, 4, 1)) +>d : Symbol(d, Decl(superPropertyAccess_ES6.ts, 14, 3)) +>MyDerived : Symbol(MyDerived, Decl(superPropertyAccess_ES6.ts, 3, 1)) var f3 = d.value; ->f3 : Symbol(f3, Decl(superPropertyAccess_ES6.ts, 16, 3)) ->d.value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) ->d : Symbol(d, Decl(superPropertyAccess_ES6.ts, 15, 3)) ->value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 2, 34)) +>f3 : Symbol(f3, Decl(superPropertyAccess_ES6.ts, 15, 3)) +>d.value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) +>d : Symbol(d, Decl(superPropertyAccess_ES6.ts, 14, 3)) +>value : Symbol(MyBase.value, Decl(superPropertyAccess_ES6.ts, 1, 34)) class A { ->A : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) +>A : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) private _property: string; ->_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) +>_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) get property() { return this._property; } ->property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 19, 30), Decl(superPropertyAccess_ES6.ts, 20, 45)) ->this._property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) ->this : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) ->_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) +>property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 18, 30), Decl(superPropertyAccess_ES6.ts, 19, 45)) +>this._property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) +>this : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) +>_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) set property(value: string) { this._property = value } ->property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 19, 30), Decl(superPropertyAccess_ES6.ts, 20, 45)) ->value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 21, 17)) ->this._property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) ->this : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) ->_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 18, 9)) ->value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 21, 17)) +>property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 18, 30), Decl(superPropertyAccess_ES6.ts, 19, 45)) +>value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 20, 17)) +>this._property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) +>this : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) +>_property : Symbol(A._property, Decl(superPropertyAccess_ES6.ts, 17, 9)) +>value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 20, 17)) } class B extends A { ->B : Symbol(B, Decl(superPropertyAccess_ES6.ts, 22, 1)) ->A : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) +>B : Symbol(B, Decl(superPropertyAccess_ES6.ts, 21, 1)) +>A : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) set property(value: string) { ->property : Symbol(B.property, Decl(superPropertyAccess_ES6.ts, 24, 19)) ->value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 25, 17)) +>property : Symbol(B.property, Decl(superPropertyAccess_ES6.ts, 23, 19)) +>value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 24, 17)) super.property = value + " addition"; ->super.property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 19, 30), Decl(superPropertyAccess_ES6.ts, 20, 45)) ->super : Symbol(A, Decl(superPropertyAccess_ES6.ts, 16, 17)) ->property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 19, 30), Decl(superPropertyAccess_ES6.ts, 20, 45)) ->value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 25, 17)) +>super.property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 18, 30), Decl(superPropertyAccess_ES6.ts, 19, 45)) +>super : Symbol(A, Decl(superPropertyAccess_ES6.ts, 15, 17)) +>property : Symbol(A.property, Decl(superPropertyAccess_ES6.ts, 18, 30), Decl(superPropertyAccess_ES6.ts, 19, 45)) +>value : Symbol(value, Decl(superPropertyAccess_ES6.ts, 24, 17)) } } diff --git a/tests/baselines/reference/superPropertyAccess_ES6.types b/tests/baselines/reference/superPropertyAccess_ES6.types index bb4082a73cf2e..c2457270ab8fe 100644 --- a/tests/baselines/reference/superPropertyAccess_ES6.types +++ b/tests/baselines/reference/superPropertyAccess_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/superPropertyAccess_ES6.ts === - class MyBase { >MyBase : MyBase diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.js b/tests/baselines/reference/superSymbolIndexedAccess2.js index bc42addc41fab..9185dc7699024 100644 --- a/tests/baselines/reference/superSymbolIndexedAccess2.js +++ b/tests/baselines/reference/superSymbolIndexedAccess2.js @@ -1,5 +1,4 @@ //// [superSymbolIndexedAccess2.ts] - class Foo { [Symbol.isConcatSpreadable]() { return 0; diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.symbols b/tests/baselines/reference/superSymbolIndexedAccess2.symbols index 68b503778e74f..1e10d3a9f9491 100644 --- a/tests/baselines/reference/superSymbolIndexedAccess2.symbols +++ b/tests/baselines/reference/superSymbolIndexedAccess2.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess2.ts === - class Foo { >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0)) @@ -13,7 +12,7 @@ class Foo { } class Bar extends Foo { ->Bar : Symbol(Bar, Decl(superSymbolIndexedAccess2.ts, 5, 1)) +>Bar : Symbol(Bar, Decl(superSymbolIndexedAccess2.ts, 4, 1)) >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0)) [Symbol.isConcatSpreadable]() { diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.types b/tests/baselines/reference/superSymbolIndexedAccess2.types index 61c760dfac757..3811c25f2fdb5 100644 --- a/tests/baselines/reference/superSymbolIndexedAccess2.types +++ b/tests/baselines/reference/superSymbolIndexedAccess2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess2.ts === - class Foo { >Foo : Foo diff --git a/tests/baselines/reference/switchBreakStatements.errors.txt b/tests/baselines/reference/switchBreakStatements.errors.txt index 229c42068c308..904b504e6686c 100644 --- a/tests/baselines/reference/switchBreakStatements.errors.txt +++ b/tests/baselines/reference/switchBreakStatements.errors.txt @@ -1,18 +1,17 @@ -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(3,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(9,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(16,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(22,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(25,18): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(31,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(34,18): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(41,10): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(43,18): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(45,26): error TS2678: Type '"a"' is not comparable to type '""'. -tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(49,34): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(2,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(8,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(15,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(21,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(24,18): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(30,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(33,18): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(40,10): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(42,18): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(44,26): error TS2678: Type '"a"' is not comparable to type '""'. +tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts(48,34): error TS2678: Type '"a"' is not comparable to type '""'. ==== tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts (11 errors) ==== - switch ('') { case 'a': ~~~ diff --git a/tests/baselines/reference/switchBreakStatements.js b/tests/baselines/reference/switchBreakStatements.js index d7fa279248c6d..534f025e2f5b8 100644 --- a/tests/baselines/reference/switchBreakStatements.js +++ b/tests/baselines/reference/switchBreakStatements.js @@ -1,5 +1,4 @@ //// [switchBreakStatements.ts] - switch ('') { case 'a': break; diff --git a/tests/baselines/reference/switchCaseWithIntersectionTypes01.errors.txt b/tests/baselines/reference/switchCaseWithIntersectionTypes01.errors.txt index d31a005842c4a..3aca9d926b763 100644 --- a/tests/baselines/reference/switchCaseWithIntersectionTypes01.errors.txt +++ b/tests/baselines/reference/switchCaseWithIntersectionTypes01.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts(19,10): error TS2678: Type '(number & true) | (number & false)' is not comparable to type 'string & number'. +tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts(18,10): error TS2678: Type '(number & true) | (number & false)' is not comparable to type 'string & number'. Type 'number & false' is not comparable to type 'string & number'. Type 'number & false' is not comparable to type 'string'. -tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts(23,10): error TS2678: Type 'boolean' is not comparable to type 'string & number'. +tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts(22,10): error TS2678: Type 'boolean' is not comparable to type 'string & number'. ==== tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithIntersectionTypes01.ts (2 errors) ==== - var strAndNum: string & number; var numAndBool: number & boolean; var str: string; diff --git a/tests/baselines/reference/switchCaseWithIntersectionTypes01.js b/tests/baselines/reference/switchCaseWithIntersectionTypes01.js index 4e0ddf7ea76a9..b4bcc2519cd97 100644 --- a/tests/baselines/reference/switchCaseWithIntersectionTypes01.js +++ b/tests/baselines/reference/switchCaseWithIntersectionTypes01.js @@ -1,5 +1,4 @@ //// [switchCaseWithIntersectionTypes01.ts] - var strAndNum: string & number; var numAndBool: number & boolean; var str: string; diff --git a/tests/baselines/reference/switchCaseWithUnionTypes01.errors.txt b/tests/baselines/reference/switchCaseWithUnionTypes01.errors.txt index 5f164f5734375..40b5b419d1fb0 100644 --- a/tests/baselines/reference/switchCaseWithUnionTypes01.errors.txt +++ b/tests/baselines/reference/switchCaseWithUnionTypes01.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithUnionTypes01.ts(23,10): error TS2678: Type 'boolean' is not comparable to type 'string | number'. +tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithUnionTypes01.ts(22,10): error TS2678: Type 'boolean' is not comparable to type 'string | number'. ==== tests/cases/conformance/types/typeRelationships/comparable/switchCaseWithUnionTypes01.ts (1 errors) ==== - var strOrNum: string | number; var numOrBool: number | boolean; var str: string; diff --git a/tests/baselines/reference/switchCaseWithUnionTypes01.js b/tests/baselines/reference/switchCaseWithUnionTypes01.js index 5c34ea674dc96..0c6aba224f685 100644 --- a/tests/baselines/reference/switchCaseWithUnionTypes01.js +++ b/tests/baselines/reference/switchCaseWithUnionTypes01.js @@ -1,5 +1,4 @@ //// [switchCaseWithUnionTypes01.ts] - var strOrNum: string | number; var numOrBool: number | boolean; var str: string; diff --git a/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt b/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt index c911886c670ff..9760ce4d99ba7 100644 --- a/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt +++ b/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(9,5): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement. -tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(21,13): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement. -tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(28,22): error TS1108: A 'return' statement can only be used within a function body. +tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(8,5): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement. +tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(20,13): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement. +tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(27,22): error TS1108: A 'return' statement can only be used within a function body. ==== tests/cases/compiler/switchStatementsWithMultipleDefaults.ts (3 errors) ==== - var x = 10; switch (x) { diff --git a/tests/baselines/reference/switchStatementsWithMultipleDefaults.js b/tests/baselines/reference/switchStatementsWithMultipleDefaults.js index a17abe5711d04..e65e10a0c99d9 100644 --- a/tests/baselines/reference/switchStatementsWithMultipleDefaults.js +++ b/tests/baselines/reference/switchStatementsWithMultipleDefaults.js @@ -1,5 +1,4 @@ //// [switchStatementsWithMultipleDefaults.ts] - var x = 10; switch (x) { diff --git a/tests/baselines/reference/systemExportAssignment.js b/tests/baselines/reference/systemExportAssignment.js index 9db066ce8b1bc..8878da7b57be7 100644 --- a/tests/baselines/reference/systemExportAssignment.js +++ b/tests/baselines/reference/systemExportAssignment.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemExportAssignment.ts] //// //// [a.d.ts] - declare var a: number; export = a; // OK, in ambient context diff --git a/tests/baselines/reference/systemExportAssignment.symbols b/tests/baselines/reference/systemExportAssignment.symbols index 73346cdc4b87c..40a7a1108dac2 100644 --- a/tests/baselines/reference/systemExportAssignment.symbols +++ b/tests/baselines/reference/systemExportAssignment.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/a.d.ts === - declare var a: number; ->a : Symbol(a, Decl(a.d.ts, 1, 11)) +>a : Symbol(a, Decl(a.d.ts, 0, 11)) export = a; // OK, in ambient context ->a : Symbol(a, Decl(a.d.ts, 1, 11)) +>a : Symbol(a, Decl(a.d.ts, 0, 11)) === tests/cases/compiler/b.ts === import * as a from "a"; diff --git a/tests/baselines/reference/systemExportAssignment.types b/tests/baselines/reference/systemExportAssignment.types index 84f896c301ddb..91901d68c48c5 100644 --- a/tests/baselines/reference/systemExportAssignment.types +++ b/tests/baselines/reference/systemExportAssignment.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.d.ts === - declare var a: number; >a : number diff --git a/tests/baselines/reference/systemExportAssignment2.errors.txt b/tests/baselines/reference/systemExportAssignment2.errors.txt index 5606f8dd63104..2e10f71bcc486 100644 --- a/tests/baselines/reference/systemExportAssignment2.errors.txt +++ b/tests/baselines/reference/systemExportAssignment2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/a.ts(3,1): error TS1218: Export assignment is not supported when '--module' flag is 'system'. +tests/cases/compiler/a.ts(2,1): error TS1218: Export assignment is not supported when '--module' flag is 'system'. ==== tests/cases/compiler/a.ts (1 errors) ==== - var a = 10; export = a; // Error: export = not allowed in ES6 ~~~~~~~~~~~ diff --git a/tests/baselines/reference/systemExportAssignment2.js b/tests/baselines/reference/systemExportAssignment2.js index a16724d964001..8c0698490fde5 100644 --- a/tests/baselines/reference/systemExportAssignment2.js +++ b/tests/baselines/reference/systemExportAssignment2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemExportAssignment2.ts] //// //// [a.ts] - var a = 10; export = a; // Error: export = not allowed in ES6 diff --git a/tests/baselines/reference/systemExportAssignment3.js b/tests/baselines/reference/systemExportAssignment3.js index 00ebe2f50c9d3..5c59fdf21e4fd 100644 --- a/tests/baselines/reference/systemExportAssignment3.js +++ b/tests/baselines/reference/systemExportAssignment3.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemExportAssignment3.ts] //// //// [modules.d.ts] - declare module "a" { var a: number; export = a; // OK, in ambient context diff --git a/tests/baselines/reference/systemExportAssignment3.symbols b/tests/baselines/reference/systemExportAssignment3.symbols index 42d4a9d009fcc..099892c706e9c 100644 --- a/tests/baselines/reference/systemExportAssignment3.symbols +++ b/tests/baselines/reference/systemExportAssignment3.symbols @@ -1,11 +1,10 @@ === tests/cases/compiler/modules.d.ts === - declare module "a" { var a: number; ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) export = a; // OK, in ambient context ->a : Symbol(a, Decl(modules.d.ts, 2, 7)) +>a : Symbol(a, Decl(modules.d.ts, 1, 7)) } === tests/cases/compiler/b.ts === diff --git a/tests/baselines/reference/systemExportAssignment3.types b/tests/baselines/reference/systemExportAssignment3.types index c32bc14ec9064..e42fadc294431 100644 --- a/tests/baselines/reference/systemExportAssignment3.types +++ b/tests/baselines/reference/systemExportAssignment3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/modules.d.ts === - declare module "a" { var a: number; >a : number diff --git a/tests/baselines/reference/systemModule1.js b/tests/baselines/reference/systemModule1.js index e2a4d309d66ce..4bd5ac092724c 100644 --- a/tests/baselines/reference/systemModule1.js +++ b/tests/baselines/reference/systemModule1.js @@ -1,5 +1,4 @@ //// [systemModule1.ts] - export var x = 1; //// [systemModule1.js] diff --git a/tests/baselines/reference/systemModule1.symbols b/tests/baselines/reference/systemModule1.symbols index d6293c21fd9a9..1ef943671de66 100644 --- a/tests/baselines/reference/systemModule1.symbols +++ b/tests/baselines/reference/systemModule1.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule1.ts === - export var x = 1; ->x : Symbol(x, Decl(systemModule1.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule1.ts, 0, 10)) diff --git a/tests/baselines/reference/systemModule1.types b/tests/baselines/reference/systemModule1.types index 927b88f4b54cf..fd0d6554b3b2f 100644 --- a/tests/baselines/reference/systemModule1.types +++ b/tests/baselines/reference/systemModule1.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule1.ts === - export var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/systemModule10.errors.txt b/tests/baselines/reference/systemModule10.errors.txt index 524e9bbe85d91..e1548b30f9087 100644 --- a/tests/baselines/reference/systemModule10.errors.txt +++ b/tests/baselines/reference/systemModule10.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/systemModule10.ts(2,20): error TS2307: Cannot find module 'file1'. -tests/cases/compiler/systemModule10.ts(3,21): error TS2307: Cannot find module 'file2'. +tests/cases/compiler/systemModule10.ts(1,20): error TS2307: Cannot find module 'file1'. +tests/cases/compiler/systemModule10.ts(2,21): error TS2307: Cannot find module 'file2'. ==== tests/cases/compiler/systemModule10.ts (2 errors) ==== - import n, {x} from 'file1' ~~~~~~~ !!! error TS2307: Cannot find module 'file1'. diff --git a/tests/baselines/reference/systemModule10.js b/tests/baselines/reference/systemModule10.js index a54afee15d79e..303e986dcc7e8 100644 --- a/tests/baselines/reference/systemModule10.js +++ b/tests/baselines/reference/systemModule10.js @@ -1,5 +1,4 @@ //// [systemModule10.ts] - import n, {x} from 'file1' import n2 = require('file2'); export {x} diff --git a/tests/baselines/reference/systemModule10_ES5.errors.txt b/tests/baselines/reference/systemModule10_ES5.errors.txt index 6f0e530516658..4a22dba31cde4 100644 --- a/tests/baselines/reference/systemModule10_ES5.errors.txt +++ b/tests/baselines/reference/systemModule10_ES5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/systemModule10_ES5.ts(2,20): error TS2307: Cannot find module 'file1'. -tests/cases/compiler/systemModule10_ES5.ts(3,21): error TS2307: Cannot find module 'file2'. +tests/cases/compiler/systemModule10_ES5.ts(1,20): error TS2307: Cannot find module 'file1'. +tests/cases/compiler/systemModule10_ES5.ts(2,21): error TS2307: Cannot find module 'file2'. ==== tests/cases/compiler/systemModule10_ES5.ts (2 errors) ==== - import n, {x} from 'file1' ~~~~~~~ !!! error TS2307: Cannot find module 'file1'. diff --git a/tests/baselines/reference/systemModule10_ES5.js b/tests/baselines/reference/systemModule10_ES5.js index bac2a6003a421..f4339b4ac16ed 100644 --- a/tests/baselines/reference/systemModule10_ES5.js +++ b/tests/baselines/reference/systemModule10_ES5.js @@ -1,5 +1,4 @@ //// [systemModule10_ES5.ts] - import n, {x} from 'file1' import n2 = require('file2'); export {x} diff --git a/tests/baselines/reference/systemModule11.errors.txt b/tests/baselines/reference/systemModule11.errors.txt index ed8f036c14f1d..46a47cc9a938a 100644 --- a/tests/baselines/reference/systemModule11.errors.txt +++ b/tests/baselines/reference/systemModule11.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/file1.ts(7,15): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/file2.ts(7,15): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/file3.ts(2,25): error TS2307: Cannot find module 'a'. -tests/cases/compiler/file3.ts(4,15): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/file4.ts(9,27): error TS2307: Cannot find module 'a'. -tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. +tests/cases/compiler/file1.ts(6,15): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/file2.ts(6,15): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/file3.ts(1,25): error TS2307: Cannot find module 'a'. +tests/cases/compiler/file3.ts(3,15): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/file4.ts(8,27): error TS2307: Cannot find module 'a'. +tests/cases/compiler/file5.ts(2,15): error TS2307: Cannot find module 'a'. ==== tests/cases/compiler/file1.ts (1 errors) ==== - // set of tests cases that checks generation of local storage for exported names @@ -18,7 +17,6 @@ tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. !!! error TS2307: Cannot find module 'bar'. ==== tests/cases/compiler/file2.ts (1 errors) ==== - var x; var y; export {x}; @@ -29,7 +27,6 @@ tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. !!! error TS2307: Cannot find module 'bar'. ==== tests/cases/compiler/file3.ts (2 errors) ==== - export {x, y as z} from 'a'; ~~~ !!! error TS2307: Cannot find module 'a'. @@ -39,7 +36,6 @@ tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. !!! error TS2307: Cannot find module 'bar'. ==== tests/cases/compiler/file4.ts (1 errors) ==== - export var x; export function foo() {} export default function (){} @@ -52,7 +48,6 @@ tests/cases/compiler/file5.ts(3,15): error TS2307: Cannot find module 'a'. !!! error TS2307: Cannot find module 'a'. ==== tests/cases/compiler/file5.ts (1 errors) ==== - function foo() {} export * from 'a'; ~~~ diff --git a/tests/baselines/reference/systemModule11.js b/tests/baselines/reference/systemModule11.js index 212a24b5e205f..b2d4d20bc8dae 100644 --- a/tests/baselines/reference/systemModule11.js +++ b/tests/baselines/reference/systemModule11.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemModule11.ts] //// //// [file1.ts] - // set of tests cases that checks generation of local storage for exported names @@ -10,7 +9,6 @@ export function foo() {} export * from 'bar'; //// [file2.ts] - var x; var y; export {x}; @@ -19,13 +17,11 @@ export {y as y1} export * from 'bar'; //// [file3.ts] - export {x, y as z} from 'a'; export default function foo() {} export * from 'bar'; //// [file4.ts] - export var x; export function foo() {} export default function (){} @@ -36,7 +32,6 @@ export {z, z1 as z2}; export {s, s1 as s2} from 'a' //// [file5.ts] - function foo() {} export * from 'a'; @@ -65,8 +60,7 @@ System.register(["bar"], function (exports_1, context_1) { exportStar_1(bar_1_1); } ], - execute: function () { - // set of tests cases that checks generation of local storage for exported names + execute: function () {// set of tests cases that checks generation of local storage for exported names } }; }); diff --git a/tests/baselines/reference/systemModule12.errors.txt b/tests/baselines/reference/systemModule12.errors.txt index 5c89e2e65d60b..57de4e1f9a5c9 100644 --- a/tests/baselines/reference/systemModule12.errors.txt +++ b/tests/baselines/reference/systemModule12.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/systemModule12.ts(3,15): error TS2307: Cannot find module 'file1'. +tests/cases/compiler/systemModule12.ts(2,15): error TS2307: Cannot find module 'file1'. ==== tests/cases/compiler/systemModule12.ts (1 errors) ==== - /// import n from 'file1' ~~~~~~~ diff --git a/tests/baselines/reference/systemModule12.js b/tests/baselines/reference/systemModule12.js index 8e94ffb54dad6..272e1349c1aec 100644 --- a/tests/baselines/reference/systemModule12.js +++ b/tests/baselines/reference/systemModule12.js @@ -1,5 +1,4 @@ //// [systemModule12.ts] - /// import n from 'file1' diff --git a/tests/baselines/reference/systemModule13.js b/tests/baselines/reference/systemModule13.js index d3fee049e0490..78b1c6cd86730 100644 --- a/tests/baselines/reference/systemModule13.js +++ b/tests/baselines/reference/systemModule13.js @@ -1,5 +1,4 @@ //// [systemModule13.ts] - export let [x,y,z] = [1, 2, 3]; export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; for ([x] of [[1]]) {} diff --git a/tests/baselines/reference/systemModule13.symbols b/tests/baselines/reference/systemModule13.symbols index 8245029e006dc..3af3b6868ab63 100644 --- a/tests/baselines/reference/systemModule13.symbols +++ b/tests/baselines/reference/systemModule13.symbols @@ -1,20 +1,19 @@ === tests/cases/compiler/systemModule13.ts === - export let [x,y,z] = [1, 2, 3]; ->x : Symbol(x, Decl(systemModule13.ts, 1, 12)) ->y : Symbol(y, Decl(systemModule13.ts, 1, 14)) ->z : Symbol(z, Decl(systemModule13.ts, 1, 16)) +>x : Symbol(x, Decl(systemModule13.ts, 0, 12)) +>y : Symbol(y, Decl(systemModule13.ts, 0, 14)) +>z : Symbol(z, Decl(systemModule13.ts, 0, 16)) export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; ->a : Symbol(a, Decl(systemModule13.ts, 2, 36)) ->z0 : Symbol(z0, Decl(systemModule13.ts, 2, 14)) ->b : Symbol(b, Decl(systemModule13.ts, 2, 44)) ->c : Symbol(c, Decl(systemModule13.ts, 2, 49)) ->z1 : Symbol(z1, Decl(systemModule13.ts, 2, 25)) ->a : Symbol(a, Decl(systemModule13.ts, 2, 36)) ->b : Symbol(b, Decl(systemModule13.ts, 2, 44)) ->c : Symbol(c, Decl(systemModule13.ts, 2, 49)) +>a : Symbol(a, Decl(systemModule13.ts, 1, 36)) +>z0 : Symbol(z0, Decl(systemModule13.ts, 1, 14)) +>b : Symbol(b, Decl(systemModule13.ts, 1, 44)) +>c : Symbol(c, Decl(systemModule13.ts, 1, 49)) +>z1 : Symbol(z1, Decl(systemModule13.ts, 1, 25)) +>a : Symbol(a, Decl(systemModule13.ts, 1, 36)) +>b : Symbol(b, Decl(systemModule13.ts, 1, 44)) +>c : Symbol(c, Decl(systemModule13.ts, 1, 49)) for ([x] of [[1]]) {} ->x : Symbol(x, Decl(systemModule13.ts, 1, 12)) +>x : Symbol(x, Decl(systemModule13.ts, 0, 12)) diff --git a/tests/baselines/reference/systemModule13.types b/tests/baselines/reference/systemModule13.types index ec85746d2bb55..0015c6c942e8f 100644 --- a/tests/baselines/reference/systemModule13.types +++ b/tests/baselines/reference/systemModule13.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule13.ts === - export let [x,y,z] = [1, 2, 3]; >x : number >y : number diff --git a/tests/baselines/reference/systemModule14.errors.txt b/tests/baselines/reference/systemModule14.errors.txt index 6ba64896df8a5..a1555fdab321b 100644 --- a/tests/baselines/reference/systemModule14.errors.txt +++ b/tests/baselines/reference/systemModule14.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/systemModule14.ts(6,17): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/systemModule14.ts(5,17): error TS2307: Cannot find module 'foo'. ==== tests/cases/compiler/systemModule14.ts (1 errors) ==== - function foo() { return a; } diff --git a/tests/baselines/reference/systemModule14.js b/tests/baselines/reference/systemModule14.js index ba4adc7aabcef..9f0c8f1ac0322 100644 --- a/tests/baselines/reference/systemModule14.js +++ b/tests/baselines/reference/systemModule14.js @@ -1,5 +1,4 @@ //// [systemModule14.ts] - function foo() { return a; } diff --git a/tests/baselines/reference/systemModule15.js b/tests/baselines/reference/systemModule15.js index 92f9bf444bd27..0db82701a0174 100644 --- a/tests/baselines/reference/systemModule15.js +++ b/tests/baselines/reference/systemModule15.js @@ -1,8 +1,6 @@ //// [tests/cases/compiler/systemModule15.ts] //// //// [file1.ts] - - import * as moduleB from "./file2" declare function use(v: any): void; @@ -12,7 +10,6 @@ use(moduleB.moduleC); use(moduleB.moduleCStar); //// [file2.ts] - import * as moduleCStar from "./file3" import {value2} from "./file4" import moduleC from "./file3" @@ -25,12 +22,10 @@ export { } //// [file3.ts] - export var value = "youpi"; export default value; //// [file4.ts] - export var value2 = "v"; //// [file3.js] diff --git a/tests/baselines/reference/systemModule15.symbols b/tests/baselines/reference/systemModule15.symbols index 2572950a7f2e0..f3fc4b39f7418 100644 --- a/tests/baselines/reference/systemModule15.symbols +++ b/tests/baselines/reference/systemModule15.symbols @@ -1,66 +1,61 @@ === tests/cases/compiler/file1.ts === - - import * as moduleB from "./file2" ->moduleB : Symbol(moduleB, Decl(file1.ts, 2, 6)) +>moduleB : Symbol(moduleB, Decl(file1.ts, 0, 6)) declare function use(v: any): void; ->use : Symbol(use, Decl(file1.ts, 2, 34)) ->v : Symbol(v, Decl(file1.ts, 4, 21)) +>use : Symbol(use, Decl(file1.ts, 0, 34)) +>v : Symbol(v, Decl(file1.ts, 2, 21)) use(moduleB.value); ->use : Symbol(use, Decl(file1.ts, 2, 34)) ->moduleB.value : Symbol(moduleB.value, Decl(file2.ts, 8, 12)) ->moduleB : Symbol(moduleB, Decl(file1.ts, 2, 6)) ->value : Symbol(moduleB.value, Decl(file2.ts, 8, 12)) +>use : Symbol(use, Decl(file1.ts, 0, 34)) +>moduleB.value : Symbol(moduleB.value, Decl(file2.ts, 7, 12)) +>moduleB : Symbol(moduleB, Decl(file1.ts, 0, 6)) +>value : Symbol(moduleB.value, Decl(file2.ts, 7, 12)) use(moduleB.moduleC); ->use : Symbol(use, Decl(file1.ts, 2, 34)) ->moduleB.moduleC : Symbol(moduleB.moduleC, Decl(file2.ts, 7, 16)) ->moduleB : Symbol(moduleB, Decl(file1.ts, 2, 6)) ->moduleC : Symbol(moduleB.moduleC, Decl(file2.ts, 7, 16)) +>use : Symbol(use, Decl(file1.ts, 0, 34)) +>moduleB.moduleC : Symbol(moduleB.moduleC, Decl(file2.ts, 6, 16)) +>moduleB : Symbol(moduleB, Decl(file1.ts, 0, 6)) +>moduleC : Symbol(moduleB.moduleC, Decl(file2.ts, 6, 16)) use(moduleB.moduleCStar); ->use : Symbol(use, Decl(file1.ts, 2, 34)) ->moduleB.moduleCStar : Symbol(moduleB.moduleCStar, Decl(file2.ts, 6, 8)) ->moduleB : Symbol(moduleB, Decl(file1.ts, 2, 6)) ->moduleCStar : Symbol(moduleB.moduleCStar, Decl(file2.ts, 6, 8)) +>use : Symbol(use, Decl(file1.ts, 0, 34)) +>moduleB.moduleCStar : Symbol(moduleB.moduleCStar, Decl(file2.ts, 5, 8)) +>moduleB : Symbol(moduleB, Decl(file1.ts, 0, 6)) +>moduleCStar : Symbol(moduleB.moduleCStar, Decl(file2.ts, 5, 8)) === tests/cases/compiler/file2.ts === - import * as moduleCStar from "./file3" ->moduleCStar : Symbol(moduleCStar, Decl(file2.ts, 1, 6)) +>moduleCStar : Symbol(moduleCStar, Decl(file2.ts, 0, 6)) import {value2} from "./file4" ->value2 : Symbol(value2, Decl(file2.ts, 2, 8)) +>value2 : Symbol(value2, Decl(file2.ts, 1, 8)) import moduleC from "./file3" ->moduleC : Symbol(moduleC, Decl(file2.ts, 3, 6)) +>moduleC : Symbol(moduleC, Decl(file2.ts, 2, 6)) import {value} from "./file3" ->value : Symbol(value, Decl(file2.ts, 4, 8)) +>value : Symbol(value, Decl(file2.ts, 3, 8)) export { moduleCStar, ->moduleCStar : Symbol(moduleCStar, Decl(file2.ts, 6, 8)) +>moduleCStar : Symbol(moduleCStar, Decl(file2.ts, 5, 8)) moduleC, ->moduleC : Symbol(moduleC, Decl(file2.ts, 7, 16)) +>moduleC : Symbol(moduleC, Decl(file2.ts, 6, 16)) value ->value : Symbol(value, Decl(file2.ts, 8, 12)) +>value : Symbol(value, Decl(file2.ts, 7, 12)) } === tests/cases/compiler/file3.ts === - export var value = "youpi"; ->value : Symbol(value, Decl(file3.ts, 1, 10)) +>value : Symbol(value, Decl(file3.ts, 0, 10)) export default value; ->value : Symbol(value, Decl(file3.ts, 1, 10)) +>value : Symbol(value, Decl(file3.ts, 0, 10)) === tests/cases/compiler/file4.ts === - export var value2 = "v"; ->value2 : Symbol(value2, Decl(file4.ts, 1, 10)) +>value2 : Symbol(value2, Decl(file4.ts, 0, 10)) diff --git a/tests/baselines/reference/systemModule15.types b/tests/baselines/reference/systemModule15.types index 7ebd1f7378e62..747583323ad8c 100644 --- a/tests/baselines/reference/systemModule15.types +++ b/tests/baselines/reference/systemModule15.types @@ -1,6 +1,4 @@ === tests/cases/compiler/file1.ts === - - import * as moduleB from "./file2" >moduleB : typeof moduleB @@ -30,7 +28,6 @@ use(moduleB.moduleCStar); >moduleCStar : typeof "tests/cases/compiler/file3" === tests/cases/compiler/file2.ts === - import * as moduleCStar from "./file3" >moduleCStar : typeof moduleCStar @@ -55,7 +52,6 @@ export { } === tests/cases/compiler/file3.ts === - export var value = "youpi"; >value : string >"youpi" : "youpi" @@ -64,7 +60,6 @@ export default value; >value : string === tests/cases/compiler/file4.ts === - export var value2 = "v"; >value2 : string >"v" : "v" diff --git a/tests/baselines/reference/systemModule16.errors.txt b/tests/baselines/reference/systemModule16.errors.txt index 33d7ba58bc228..6e65f7e31a1e1 100644 --- a/tests/baselines/reference/systemModule16.errors.txt +++ b/tests/baselines/reference/systemModule16.errors.txt @@ -1,17 +1,16 @@ -tests/cases/compiler/systemModule16.ts(2,20): error TS2307: Cannot find module 'foo'. -tests/cases/compiler/systemModule16.ts(3,20): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/systemModule16.ts(4,15): error TS2307: Cannot find module 'foo'. -tests/cases/compiler/systemModule16.ts(5,15): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/systemModule16.ts(8,32): error TS2307: Cannot find module 'foo'. -tests/cases/compiler/systemModule16.ts(9,32): error TS2307: Cannot find module 'bar'. -tests/cases/compiler/systemModule16.ts(11,1): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/compiler/systemModule16.ts(11,1): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/compiler/systemModule16.ts(11,1): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/compiler/systemModule16.ts(11,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/compiler/systemModule16.ts(1,20): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/systemModule16.ts(2,20): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/systemModule16.ts(3,15): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/systemModule16.ts(4,15): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/systemModule16.ts(7,32): error TS2307: Cannot find module 'foo'. +tests/cases/compiler/systemModule16.ts(8,32): error TS2307: Cannot find module 'bar'. +tests/cases/compiler/systemModule16.ts(10,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/compiler/systemModule16.ts(10,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/compiler/systemModule16.ts(10,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/compiler/systemModule16.ts(10,1): error TS2695: Left side of comma operator is unused and has no side effects. ==== tests/cases/compiler/systemModule16.ts (10 errors) ==== - import * as x from "foo"; ~~~~~ !!! error TS2307: Cannot find module 'foo'. diff --git a/tests/baselines/reference/systemModule16.js b/tests/baselines/reference/systemModule16.js index 86b6a4482151e..8e912d3c63c2d 100644 --- a/tests/baselines/reference/systemModule16.js +++ b/tests/baselines/reference/systemModule16.js @@ -1,5 +1,4 @@ //// [systemModule16.ts] - import * as x from "foo"; import * as y from "bar"; export * from "foo"; diff --git a/tests/baselines/reference/systemModule17.js b/tests/baselines/reference/systemModule17.js index bcdf661235639..bab203d8aa231 100644 --- a/tests/baselines/reference/systemModule17.js +++ b/tests/baselines/reference/systemModule17.js @@ -1,13 +1,10 @@ //// [tests/cases/compiler/systemModule17.ts] //// //// [f1.ts] - - export class A {} export interface I {} //// [f2.ts] - var x = 1; interface I { } diff --git a/tests/baselines/reference/systemModule17.symbols b/tests/baselines/reference/systemModule17.symbols index 3bf19dad950b6..358ef26542cef 100644 --- a/tests/baselines/reference/systemModule17.symbols +++ b/tests/baselines/reference/systemModule17.symbols @@ -1,93 +1,90 @@ === tests/cases/compiler/f1.ts === - - export class A {} >A : Symbol(A, Decl(f1.ts, 0, 0)) export interface I {} ->I : Symbol(I, Decl(f1.ts, 2, 17)) +>I : Symbol(I, Decl(f1.ts, 0, 17)) === tests/cases/compiler/f2.ts === - var x = 1; ->x : Symbol(x, Decl(f2.ts, 1, 3)) +>x : Symbol(x, Decl(f2.ts, 0, 3)) interface I { } ->I : Symbol(I, Decl(f2.ts, 1, 10)) +>I : Symbol(I, Decl(f2.ts, 0, 10)) namespace N { ->N : Symbol(N, Decl(f2.ts, 2, 15)) +>N : Symbol(N, Decl(f2.ts, 1, 15)) export var x = 1; ->x : Symbol(x, Decl(f2.ts, 5, 11)) +>x : Symbol(x, Decl(f2.ts, 4, 11)) export interface I { } ->I : Symbol(I, Decl(f2.ts, 5, 18)) +>I : Symbol(I, Decl(f2.ts, 4, 18)) } import IX = N.x; ->IX : Symbol(IX, Decl(f2.ts, 7, 1)) ->N : Symbol(N, Decl(f2.ts, 2, 15)) ->x : Symbol(IX, Decl(f2.ts, 5, 11)) +>IX : Symbol(IX, Decl(f2.ts, 6, 1)) +>N : Symbol(N, Decl(f2.ts, 1, 15)) +>x : Symbol(IX, Decl(f2.ts, 4, 11)) import II = N.I; ->II : Symbol(II, Decl(f2.ts, 9, 16)) ->N : Symbol(N, Decl(f2.ts, 2, 15)) ->I : Symbol(II, Decl(f2.ts, 5, 18)) +>II : Symbol(II, Decl(f2.ts, 8, 16)) +>N : Symbol(N, Decl(f2.ts, 1, 15)) +>I : Symbol(II, Decl(f2.ts, 4, 18)) import { A, A as EA, I as EI } from "f1"; ->A : Symbol(A, Decl(f2.ts, 11, 8)) ->A : Symbol(EA, Decl(f2.ts, 11, 11)) ->EA : Symbol(EA, Decl(f2.ts, 11, 11)) ->I : Symbol(EI, Decl(f2.ts, 11, 20)) ->EI : Symbol(EI, Decl(f2.ts, 11, 20)) +>A : Symbol(A, Decl(f2.ts, 10, 8)) +>A : Symbol(EA, Decl(f2.ts, 10, 11)) +>EA : Symbol(EA, Decl(f2.ts, 10, 11)) +>I : Symbol(EI, Decl(f2.ts, 10, 20)) +>EI : Symbol(EI, Decl(f2.ts, 10, 20)) export {x}; ->x : Symbol(x, Decl(f2.ts, 13, 8)) +>x : Symbol(x, Decl(f2.ts, 12, 8)) export {x as x1}; ->x : Symbol(x1, Decl(f2.ts, 14, 8)) ->x1 : Symbol(x1, Decl(f2.ts, 14, 8)) +>x : Symbol(x1, Decl(f2.ts, 13, 8)) +>x1 : Symbol(x1, Decl(f2.ts, 13, 8)) export {I}; ->I : Symbol(I, Decl(f2.ts, 16, 8)) +>I : Symbol(I, Decl(f2.ts, 15, 8)) export {I as I1}; ->I : Symbol(I1, Decl(f2.ts, 17, 8)) ->I1 : Symbol(I1, Decl(f2.ts, 17, 8)) +>I : Symbol(I1, Decl(f2.ts, 16, 8)) +>I1 : Symbol(I1, Decl(f2.ts, 16, 8)) export {A}; ->A : Symbol(A, Decl(f2.ts, 19, 8)) +>A : Symbol(A, Decl(f2.ts, 18, 8)) export {A as A1}; ->A : Symbol(A1, Decl(f2.ts, 20, 8)) ->A1 : Symbol(A1, Decl(f2.ts, 20, 8)) +>A : Symbol(A1, Decl(f2.ts, 19, 8)) +>A1 : Symbol(A1, Decl(f2.ts, 19, 8)) export {EA}; ->EA : Symbol(EA, Decl(f2.ts, 22, 8)) +>EA : Symbol(EA, Decl(f2.ts, 21, 8)) export {EA as EA1}; ->EA : Symbol(EA1, Decl(f2.ts, 23, 8)) ->EA1 : Symbol(EA1, Decl(f2.ts, 23, 8)) +>EA : Symbol(EA1, Decl(f2.ts, 22, 8)) +>EA1 : Symbol(EA1, Decl(f2.ts, 22, 8)) export {EI }; ->EI : Symbol(EI, Decl(f2.ts, 25, 8)) +>EI : Symbol(EI, Decl(f2.ts, 24, 8)) export {EI as EI1}; ->EI : Symbol(EI1, Decl(f2.ts, 26, 8)) ->EI1 : Symbol(EI1, Decl(f2.ts, 26, 8)) +>EI : Symbol(EI1, Decl(f2.ts, 25, 8)) +>EI1 : Symbol(EI1, Decl(f2.ts, 25, 8)) export {IX}; ->IX : Symbol(IX, Decl(f2.ts, 28, 8)) +>IX : Symbol(IX, Decl(f2.ts, 27, 8)) export {IX as IX1}; ->IX : Symbol(IX1, Decl(f2.ts, 29, 8)) ->IX1 : Symbol(IX1, Decl(f2.ts, 29, 8)) +>IX : Symbol(IX1, Decl(f2.ts, 28, 8)) +>IX1 : Symbol(IX1, Decl(f2.ts, 28, 8)) export {II}; ->II : Symbol(II, Decl(f2.ts, 31, 8)) +>II : Symbol(II, Decl(f2.ts, 30, 8)) export {II as II1}; ->II : Symbol(II1, Decl(f2.ts, 32, 8)) ->II1 : Symbol(II1, Decl(f2.ts, 32, 8)) +>II : Symbol(II1, Decl(f2.ts, 31, 8)) +>II1 : Symbol(II1, Decl(f2.ts, 31, 8)) diff --git a/tests/baselines/reference/systemModule17.types b/tests/baselines/reference/systemModule17.types index c0a0a7dc58432..7819ddd7e3294 100644 --- a/tests/baselines/reference/systemModule17.types +++ b/tests/baselines/reference/systemModule17.types @@ -1,6 +1,4 @@ === tests/cases/compiler/f1.ts === - - export class A {} >A : A @@ -8,7 +6,6 @@ export interface I {} >I : I === tests/cases/compiler/f2.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/systemModule2.errors.txt b/tests/baselines/reference/systemModule2.errors.txt index e323e2cde2eea..2c79d6434b4f6 100644 --- a/tests/baselines/reference/systemModule2.errors.txt +++ b/tests/baselines/reference/systemModule2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/systemModule2.ts(3,1): error TS1218: Export assignment is not supported when '--module' flag is 'system'. +tests/cases/compiler/systemModule2.ts(2,1): error TS1218: Export assignment is not supported when '--module' flag is 'system'. ==== tests/cases/compiler/systemModule2.ts (1 errors) ==== - var x = 1; export = x; ~~~~~~~~~~~ diff --git a/tests/baselines/reference/systemModule2.js b/tests/baselines/reference/systemModule2.js index c267eaefb4347..1180d9e3dc9a0 100644 --- a/tests/baselines/reference/systemModule2.js +++ b/tests/baselines/reference/systemModule2.js @@ -1,5 +1,4 @@ //// [systemModule2.ts] - var x = 1; export = x; diff --git a/tests/baselines/reference/systemModule3.js b/tests/baselines/reference/systemModule3.js index 109cbb7187cf3..b7a91ac5d4ac8 100644 --- a/tests/baselines/reference/systemModule3.js +++ b/tests/baselines/reference/systemModule3.js @@ -1,20 +1,15 @@ //// [tests/cases/compiler/systemModule3.ts] //// //// [file1.ts] - - export default function() {} //// [file2.ts] - export default function f() {} //// [file3.ts] - export default class C {} //// [file4.ts] - export default class {} //// [file1.js] diff --git a/tests/baselines/reference/systemModule3.symbols b/tests/baselines/reference/systemModule3.symbols index a8f8ab469159f..a8226acebdc7b 100644 --- a/tests/baselines/reference/systemModule3.symbols +++ b/tests/baselines/reference/systemModule3.symbols @@ -1,19 +1,14 @@ === tests/cases/compiler/file1.ts === - -No type information for this code. -No type information for this code.export default function() {} +export default function() {} No type information for this code. No type information for this code.=== tests/cases/compiler/file2.ts === - export default function f() {} >f : Symbol(f, Decl(file2.ts, 0, 0)) === tests/cases/compiler/file3.ts === - export default class C {} >C : Symbol(C, Decl(file3.ts, 0, 0)) === tests/cases/compiler/file4.ts === - -No type information for this code.export default class {} +export default class {} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/systemModule3.types b/tests/baselines/reference/systemModule3.types index 4448588b74c55..691f5bdaaf07f 100644 --- a/tests/baselines/reference/systemModule3.types +++ b/tests/baselines/reference/systemModule3.types @@ -1,19 +1,14 @@ === tests/cases/compiler/file1.ts === - -No type information for this code. -No type information for this code.export default function() {} +export default function() {} No type information for this code. No type information for this code.=== tests/cases/compiler/file2.ts === - export default function f() {} >f : () => void === tests/cases/compiler/file3.ts === - export default class C {} >C : C === tests/cases/compiler/file4.ts === - -No type information for this code.export default class {} +export default class {} No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/systemModule4.js b/tests/baselines/reference/systemModule4.js index 22a4755e9fb53..9b59265f832df 100644 --- a/tests/baselines/reference/systemModule4.js +++ b/tests/baselines/reference/systemModule4.js @@ -1,5 +1,4 @@ //// [systemModule4.ts] - export var x = 1; export var y; diff --git a/tests/baselines/reference/systemModule4.symbols b/tests/baselines/reference/systemModule4.symbols index b0bc1a1cfc16f..c90c35de201d4 100644 --- a/tests/baselines/reference/systemModule4.symbols +++ b/tests/baselines/reference/systemModule4.symbols @@ -1,8 +1,7 @@ === tests/cases/compiler/systemModule4.ts === - export var x = 1; ->x : Symbol(x, Decl(systemModule4.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule4.ts, 0, 10)) export var y; ->y : Symbol(y, Decl(systemModule4.ts, 2, 10)) +>y : Symbol(y, Decl(systemModule4.ts, 1, 10)) diff --git a/tests/baselines/reference/systemModule4.types b/tests/baselines/reference/systemModule4.types index 8a871a987a7f8..4568dd053a846 100644 --- a/tests/baselines/reference/systemModule4.types +++ b/tests/baselines/reference/systemModule4.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule4.ts === - export var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/systemModule5.js b/tests/baselines/reference/systemModule5.js index ada3b33916824..a1e8de3e82cd3 100644 --- a/tests/baselines/reference/systemModule5.js +++ b/tests/baselines/reference/systemModule5.js @@ -1,5 +1,4 @@ //// [systemModule5.ts] - export function foo() {} diff --git a/tests/baselines/reference/systemModule5.symbols b/tests/baselines/reference/systemModule5.symbols index b2f896dd18359..fb760600b30a6 100644 --- a/tests/baselines/reference/systemModule5.symbols +++ b/tests/baselines/reference/systemModule5.symbols @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule5.ts === - export function foo() {} >foo : Symbol(foo, Decl(systemModule5.ts, 0, 0)) diff --git a/tests/baselines/reference/systemModule5.types b/tests/baselines/reference/systemModule5.types index 0061f002801fa..91d88f04fb068 100644 --- a/tests/baselines/reference/systemModule5.types +++ b/tests/baselines/reference/systemModule5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule5.ts === - export function foo() {} >foo : () => void diff --git a/tests/baselines/reference/systemModule6.js b/tests/baselines/reference/systemModule6.js index 5e1f51dd6976a..3632881127a73 100644 --- a/tests/baselines/reference/systemModule6.js +++ b/tests/baselines/reference/systemModule6.js @@ -1,5 +1,4 @@ //// [systemModule6.ts] - export class C {} function foo() { new C(); diff --git a/tests/baselines/reference/systemModule6.symbols b/tests/baselines/reference/systemModule6.symbols index e01d276559a74..4cf8ad81039b1 100644 --- a/tests/baselines/reference/systemModule6.symbols +++ b/tests/baselines/reference/systemModule6.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/systemModule6.ts === - export class C {} >C : Symbol(C, Decl(systemModule6.ts, 0, 0)) function foo() { ->foo : Symbol(foo, Decl(systemModule6.ts, 1, 17)) +>foo : Symbol(foo, Decl(systemModule6.ts, 0, 17)) new C(); >C : Symbol(C, Decl(systemModule6.ts, 0, 0)) diff --git a/tests/baselines/reference/systemModule6.types b/tests/baselines/reference/systemModule6.types index cc8a97c066e2f..31a445e573213 100644 --- a/tests/baselines/reference/systemModule6.types +++ b/tests/baselines/reference/systemModule6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule6.ts === - export class C {} >C : C diff --git a/tests/baselines/reference/systemModule7.js b/tests/baselines/reference/systemModule7.js index d25ca627e441b..970195379f4e2 100644 --- a/tests/baselines/reference/systemModule7.js +++ b/tests/baselines/reference/systemModule7.js @@ -1,5 +1,4 @@ //// [systemModule7.ts] - // filename: instantiatedModule.ts export module M { var x = 1; diff --git a/tests/baselines/reference/systemModule7.symbols b/tests/baselines/reference/systemModule7.symbols index e47ab5510b5a2..4f5c4a127bcb1 100644 --- a/tests/baselines/reference/systemModule7.symbols +++ b/tests/baselines/reference/systemModule7.symbols @@ -1,17 +1,16 @@ === tests/cases/compiler/systemModule7.ts === - // filename: instantiatedModule.ts export module M { ->M : Symbol(M, Decl(systemModule7.ts, 0, 0), Decl(systemModule7.ts, 4, 1)) +>M : Symbol(M, Decl(systemModule7.ts, 0, 0), Decl(systemModule7.ts, 3, 1)) var x = 1; ->x : Symbol(x, Decl(systemModule7.ts, 3, 7)) +>x : Symbol(x, Decl(systemModule7.ts, 2, 7)) } // filename: nonInstantiatedModule.ts export module M { ->M : Symbol(M, Decl(systemModule7.ts, 0, 0), Decl(systemModule7.ts, 4, 1)) +>M : Symbol(M, Decl(systemModule7.ts, 0, 0), Decl(systemModule7.ts, 3, 1)) interface I {} ->I : Symbol(I, Decl(systemModule7.ts, 7, 17)) +>I : Symbol(I, Decl(systemModule7.ts, 6, 17)) } diff --git a/tests/baselines/reference/systemModule7.types b/tests/baselines/reference/systemModule7.types index 33003f5fa37d7..ec39957501f67 100644 --- a/tests/baselines/reference/systemModule7.types +++ b/tests/baselines/reference/systemModule7.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule7.ts === - // filename: instantiatedModule.ts export module M { >M : typeof M diff --git a/tests/baselines/reference/systemModule8.js b/tests/baselines/reference/systemModule8.js index 3065d4f35b301..af029967a99a3 100644 --- a/tests/baselines/reference/systemModule8.js +++ b/tests/baselines/reference/systemModule8.js @@ -1,5 +1,4 @@ //// [systemModule8.ts] - export var x; x = 1; x++; diff --git a/tests/baselines/reference/systemModule8.symbols b/tests/baselines/reference/systemModule8.symbols index 719d48e4592db..d611f74dbc605 100644 --- a/tests/baselines/reference/systemModule8.symbols +++ b/tests/baselines/reference/systemModule8.symbols @@ -1,92 +1,91 @@ === tests/cases/compiler/systemModule8.ts === - export var x; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x = 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x++; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x--; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) ++x; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) --x; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x += 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x -= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x *= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x /= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x |= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x &= 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x + 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x - 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x & 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) x | 1; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (x = 5;;x++) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (x = 8;;x--) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (x = 15;;++x) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (x = 18;;--x) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) for (let x = 50;;) {} ->x : Symbol(x, Decl(systemModule8.ts, 22, 8)) +>x : Symbol(x, Decl(systemModule8.ts, 21, 8)) function foo() { ->foo : Symbol(foo, Decl(systemModule8.ts, 22, 21)) +>foo : Symbol(foo, Decl(systemModule8.ts, 21, 21)) x = 100; ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) } export let [y] = [1]; ->y : Symbol(y, Decl(systemModule8.ts, 27, 12)) +>y : Symbol(y, Decl(systemModule8.ts, 26, 12)) export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; ->a : Symbol(a, Decl(systemModule8.ts, 28, 36)) ->z0 : Symbol(z0, Decl(systemModule8.ts, 28, 14)) ->b : Symbol(b, Decl(systemModule8.ts, 28, 44)) ->c : Symbol(c, Decl(systemModule8.ts, 28, 49)) ->z1 : Symbol(z1, Decl(systemModule8.ts, 28, 25)) ->a : Symbol(a, Decl(systemModule8.ts, 28, 36)) ->b : Symbol(b, Decl(systemModule8.ts, 28, 44)) ->c : Symbol(c, Decl(systemModule8.ts, 28, 49)) +>a : Symbol(a, Decl(systemModule8.ts, 27, 36)) +>z0 : Symbol(z0, Decl(systemModule8.ts, 27, 14)) +>b : Symbol(b, Decl(systemModule8.ts, 27, 44)) +>c : Symbol(c, Decl(systemModule8.ts, 27, 49)) +>z1 : Symbol(z1, Decl(systemModule8.ts, 27, 25)) +>a : Symbol(a, Decl(systemModule8.ts, 27, 36)) +>b : Symbol(b, Decl(systemModule8.ts, 27, 44)) +>c : Symbol(c, Decl(systemModule8.ts, 27, 49)) for ([x] of [[1]]) {} ->x : Symbol(x, Decl(systemModule8.ts, 1, 10)) +>x : Symbol(x, Decl(systemModule8.ts, 0, 10)) diff --git a/tests/baselines/reference/systemModule8.types b/tests/baselines/reference/systemModule8.types index f31e77c346d1e..01d9b094165f1 100644 --- a/tests/baselines/reference/systemModule8.types +++ b/tests/baselines/reference/systemModule8.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModule8.ts === - export var x; >x : any diff --git a/tests/baselines/reference/systemModule9.errors.txt b/tests/baselines/reference/systemModule9.errors.txt index 27af70cce6a03..bedcc561058f2 100644 --- a/tests/baselines/reference/systemModule9.errors.txt +++ b/tests/baselines/reference/systemModule9.errors.txt @@ -1,13 +1,12 @@ -tests/cases/compiler/systemModule9.ts(2,21): error TS2307: Cannot find module 'file1'. -tests/cases/compiler/systemModule9.ts(3,25): error TS2307: Cannot find module 'file2'. -tests/cases/compiler/systemModule9.ts(4,15): error TS2307: Cannot find module 'file3'. -tests/cases/compiler/systemModule9.ts(6,25): error TS2307: Cannot find module 'file5'. -tests/cases/compiler/systemModule9.ts(7,22): error TS2307: Cannot find module 'file6'. -tests/cases/compiler/systemModule9.ts(17,15): error TS2307: Cannot find module 'file7'. +tests/cases/compiler/systemModule9.ts(1,21): error TS2307: Cannot find module 'file1'. +tests/cases/compiler/systemModule9.ts(2,25): error TS2307: Cannot find module 'file2'. +tests/cases/compiler/systemModule9.ts(3,15): error TS2307: Cannot find module 'file3'. +tests/cases/compiler/systemModule9.ts(5,25): error TS2307: Cannot find module 'file5'. +tests/cases/compiler/systemModule9.ts(6,22): error TS2307: Cannot find module 'file6'. +tests/cases/compiler/systemModule9.ts(16,15): error TS2307: Cannot find module 'file7'. ==== tests/cases/compiler/systemModule9.ts (6 errors) ==== - import * as ns from 'file1'; ~~~~~~~ !!! error TS2307: Cannot find module 'file1'. diff --git a/tests/baselines/reference/systemModule9.js b/tests/baselines/reference/systemModule9.js index fce3aa1bdf4dd..b83d62f9cf808 100644 --- a/tests/baselines/reference/systemModule9.js +++ b/tests/baselines/reference/systemModule9.js @@ -1,5 +1,4 @@ //// [systemModule9.ts] - import * as ns from 'file1'; import {a, b as c} from 'file2'; import d from 'file3' diff --git a/tests/baselines/reference/systemModuleAmbientDeclarations.js b/tests/baselines/reference/systemModuleAmbientDeclarations.js index 9714f138c5ec6..45a484be44d51 100644 --- a/tests/baselines/reference/systemModuleAmbientDeclarations.js +++ b/tests/baselines/reference/systemModuleAmbientDeclarations.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemModuleAmbientDeclarations.ts] //// //// [file1.ts] - declare class Promise { } declare function Foo(): void; declare class C {} diff --git a/tests/baselines/reference/systemModuleAmbientDeclarations.symbols b/tests/baselines/reference/systemModuleAmbientDeclarations.symbols index c2e8557270b3f..5143731caf0c6 100644 --- a/tests/baselines/reference/systemModuleAmbientDeclarations.symbols +++ b/tests/baselines/reference/systemModuleAmbientDeclarations.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/file1.ts === - declare class Promise { } >Promise : Symbol(Promise, Decl(file1.ts, 0, 0)) declare function Foo(): void; ->Foo : Symbol(Foo, Decl(file1.ts, 1, 25)) +>Foo : Symbol(Foo, Decl(file1.ts, 0, 25)) declare class C {} ->C : Symbol(C, Decl(file1.ts, 2, 29)) +>C : Symbol(C, Decl(file1.ts, 1, 29)) declare enum E {X = 1}; ->E : Symbol(E, Decl(file1.ts, 3, 18)) ->X : Symbol(E.X, Decl(file1.ts, 4, 16)) +>E : Symbol(E, Decl(file1.ts, 2, 18)) +>X : Symbol(E.X, Decl(file1.ts, 3, 16)) export var promise = Promise; ->promise : Symbol(promise, Decl(file1.ts, 6, 10)) +>promise : Symbol(promise, Decl(file1.ts, 5, 10)) >Promise : Symbol(Promise, Decl(file1.ts, 0, 0)) export var foo = Foo; ->foo : Symbol(foo, Decl(file1.ts, 7, 10)) ->Foo : Symbol(Foo, Decl(file1.ts, 1, 25)) +>foo : Symbol(foo, Decl(file1.ts, 6, 10)) +>Foo : Symbol(Foo, Decl(file1.ts, 0, 25)) export var c = C; ->c : Symbol(c, Decl(file1.ts, 8, 10)) ->C : Symbol(C, Decl(file1.ts, 2, 29)) +>c : Symbol(c, Decl(file1.ts, 7, 10)) +>C : Symbol(C, Decl(file1.ts, 1, 29)) export var e = E; ->e : Symbol(e, Decl(file1.ts, 9, 10)) ->E : Symbol(E, Decl(file1.ts, 3, 18)) +>e : Symbol(e, Decl(file1.ts, 8, 10)) +>E : Symbol(E, Decl(file1.ts, 2, 18)) === tests/cases/compiler/file2.ts === export declare function foo(); diff --git a/tests/baselines/reference/systemModuleAmbientDeclarations.types b/tests/baselines/reference/systemModuleAmbientDeclarations.types index 04c4f2d49df7e..83a1bb857c7e0 100644 --- a/tests/baselines/reference/systemModuleAmbientDeclarations.types +++ b/tests/baselines/reference/systemModuleAmbientDeclarations.types @@ -1,5 +1,4 @@ === tests/cases/compiler/file1.ts === - declare class Promise { } >Promise : Promise diff --git a/tests/baselines/reference/systemModuleConstEnums.js b/tests/baselines/reference/systemModuleConstEnums.js index dbb88c61e1412..d99d3b22d4481 100644 --- a/tests/baselines/reference/systemModuleConstEnums.js +++ b/tests/baselines/reference/systemModuleConstEnums.js @@ -1,5 +1,4 @@ //// [systemModuleConstEnums.ts] - declare function use(a: any); const enum TopLevelConstEnum { X } diff --git a/tests/baselines/reference/systemModuleConstEnums.symbols b/tests/baselines/reference/systemModuleConstEnums.symbols index 171f24628ece1..7ebb52d3909a3 100644 --- a/tests/baselines/reference/systemModuleConstEnums.symbols +++ b/tests/baselines/reference/systemModuleConstEnums.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/systemModuleConstEnums.ts === - declare function use(a: any); >use : Symbol(use, Decl(systemModuleConstEnums.ts, 0, 0)) ->a : Symbol(a, Decl(systemModuleConstEnums.ts, 1, 21)) +>a : Symbol(a, Decl(systemModuleConstEnums.ts, 0, 21)) const enum TopLevelConstEnum { X } ->TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 1, 29)) ->X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 2, 30)) +>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 0, 29)) +>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 1, 30)) export function foo() { ->foo : Symbol(foo, Decl(systemModuleConstEnums.ts, 2, 34)) +>foo : Symbol(foo, Decl(systemModuleConstEnums.ts, 1, 34)) use(TopLevelConstEnum.X); >use : Symbol(use, Decl(systemModuleConstEnums.ts, 0, 0)) ->TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 2, 30)) ->TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 1, 29)) ->X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 2, 30)) +>TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 1, 30)) +>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnums.ts, 0, 29)) +>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 1, 30)) use(M.NonTopLevelConstEnum.X); >use : Symbol(use, Decl(systemModuleConstEnums.ts, 0, 0)) ->M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 10, 44)) ->M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 9, 10)) ->M : Symbol(M, Decl(systemModuleConstEnums.ts, 7, 1)) ->NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 9, 10)) ->X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 10, 44)) +>M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 9, 44)) +>M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 8, 10)) +>M : Symbol(M, Decl(systemModuleConstEnums.ts, 6, 1)) +>NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 8, 10)) +>X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 9, 44)) } module M { ->M : Symbol(M, Decl(systemModuleConstEnums.ts, 7, 1)) +>M : Symbol(M, Decl(systemModuleConstEnums.ts, 6, 1)) export const enum NonTopLevelConstEnum { X } ->NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 9, 10)) ->X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 10, 44)) +>NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnums.ts, 8, 10)) +>X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnums.ts, 9, 44)) } diff --git a/tests/baselines/reference/systemModuleConstEnums.types b/tests/baselines/reference/systemModuleConstEnums.types index 193de0da3ab58..08edfd24b282f 100644 --- a/tests/baselines/reference/systemModuleConstEnums.types +++ b/tests/baselines/reference/systemModuleConstEnums.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModuleConstEnums.ts === - declare function use(a: any); >use : (a: any) => any >a : any diff --git a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js index 132d27a4ea03c..4b1e28e9fda50 100644 --- a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js +++ b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.js @@ -1,5 +1,4 @@ //// [systemModuleConstEnumsSeparateCompilation.ts] - declare function use(a: any); const enum TopLevelConstEnum { X } diff --git a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols index d57740b75e960..3385728ef81e8 100644 --- a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols +++ b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.symbols @@ -1,35 +1,34 @@ === tests/cases/compiler/systemModuleConstEnumsSeparateCompilation.ts === - declare function use(a: any); >use : Symbol(use, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 0)) ->a : Symbol(a, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 21)) +>a : Symbol(a, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 21)) const enum TopLevelConstEnum { X } ->TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 29)) ->X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 30)) +>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 29)) +>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 30)) export function foo() { ->foo : Symbol(foo, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 34)) +>foo : Symbol(foo, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 34)) use(TopLevelConstEnum.X); >use : Symbol(use, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 0)) ->TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 30)) ->TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 29)) ->X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 2, 30)) +>TopLevelConstEnum.X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 30)) +>TopLevelConstEnum : Symbol(TopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 29)) +>X : Symbol(TopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 1, 30)) use(M.NonTopLevelConstEnum.X); >use : Symbol(use, Decl(systemModuleConstEnumsSeparateCompilation.ts, 0, 0)) ->M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 10, 44)) ->M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 10)) ->M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 7, 1)) ->NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 10)) ->X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 10, 44)) +>M.NonTopLevelConstEnum.X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 44)) +>M.NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 8, 10)) +>M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 6, 1)) +>NonTopLevelConstEnum : Symbol(M.NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 8, 10)) +>X : Symbol(M.NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 44)) } module M { ->M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 7, 1)) +>M : Symbol(M, Decl(systemModuleConstEnumsSeparateCompilation.ts, 6, 1)) export const enum NonTopLevelConstEnum { X } ->NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 10)) ->X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 10, 44)) +>NonTopLevelConstEnum : Symbol(NonTopLevelConstEnum, Decl(systemModuleConstEnumsSeparateCompilation.ts, 8, 10)) +>X : Symbol(NonTopLevelConstEnum.X, Decl(systemModuleConstEnumsSeparateCompilation.ts, 9, 44)) } diff --git a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types index c3a352f66ecad..23e34a0d40ff1 100644 --- a/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types +++ b/tests/baselines/reference/systemModuleConstEnumsSeparateCompilation.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModuleConstEnumsSeparateCompilation.ts === - declare function use(a: any); >use : (a: any) => any >a : any diff --git a/tests/baselines/reference/systemModuleDeclarationMerging.js b/tests/baselines/reference/systemModuleDeclarationMerging.js index d60a315b0a67b..9a48570fb113e 100644 --- a/tests/baselines/reference/systemModuleDeclarationMerging.js +++ b/tests/baselines/reference/systemModuleDeclarationMerging.js @@ -1,5 +1,4 @@ //// [systemModuleDeclarationMerging.ts] - export function F() {} export module F { var x; } diff --git a/tests/baselines/reference/systemModuleDeclarationMerging.symbols b/tests/baselines/reference/systemModuleDeclarationMerging.symbols index 8efce4022ba1f..eef746550780f 100644 --- a/tests/baselines/reference/systemModuleDeclarationMerging.symbols +++ b/tests/baselines/reference/systemModuleDeclarationMerging.symbols @@ -1,23 +1,22 @@ === tests/cases/compiler/systemModuleDeclarationMerging.ts === - export function F() {} ->F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 1, 22)) +>F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 0, 22)) export module F { var x; } ->F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 1, 22)) ->x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 2, 21)) +>F : Symbol(F, Decl(systemModuleDeclarationMerging.ts, 0, 0), Decl(systemModuleDeclarationMerging.ts, 0, 22)) +>x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 1, 21)) export class C {} ->C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 2, 26), Decl(systemModuleDeclarationMerging.ts, 4, 17)) +>C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 1, 26), Decl(systemModuleDeclarationMerging.ts, 3, 17)) export module C { var x; } ->C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 2, 26), Decl(systemModuleDeclarationMerging.ts, 4, 17)) ->x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 5, 21)) +>C : Symbol(C, Decl(systemModuleDeclarationMerging.ts, 1, 26), Decl(systemModuleDeclarationMerging.ts, 3, 17)) +>x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 4, 21)) export enum E {} ->E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 5, 26), Decl(systemModuleDeclarationMerging.ts, 7, 16)) +>E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 4, 26), Decl(systemModuleDeclarationMerging.ts, 6, 16)) export module E { var x; } ->E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 5, 26), Decl(systemModuleDeclarationMerging.ts, 7, 16)) ->x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 8, 21)) +>E : Symbol(E, Decl(systemModuleDeclarationMerging.ts, 4, 26), Decl(systemModuleDeclarationMerging.ts, 6, 16)) +>x : Symbol(x, Decl(systemModuleDeclarationMerging.ts, 7, 21)) diff --git a/tests/baselines/reference/systemModuleDeclarationMerging.types b/tests/baselines/reference/systemModuleDeclarationMerging.types index 20bf1e67f51d1..9f0f03b23f148 100644 --- a/tests/baselines/reference/systemModuleDeclarationMerging.types +++ b/tests/baselines/reference/systemModuleDeclarationMerging.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModuleDeclarationMerging.ts === - export function F() {} >F : typeof F diff --git a/tests/baselines/reference/systemModuleExportDefault.js b/tests/baselines/reference/systemModuleExportDefault.js index 67341a04a0b92..98fa71de5e2c9 100644 --- a/tests/baselines/reference/systemModuleExportDefault.js +++ b/tests/baselines/reference/systemModuleExportDefault.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemModuleExportDefault.ts] //// //// [file1.ts] - export default function() {} //// [file2.ts] diff --git a/tests/baselines/reference/systemModuleExportDefault.symbols b/tests/baselines/reference/systemModuleExportDefault.symbols index d6e7cde9b71a5..af12bc2d6a8ab 100644 --- a/tests/baselines/reference/systemModuleExportDefault.symbols +++ b/tests/baselines/reference/systemModuleExportDefault.symbols @@ -1,6 +1,5 @@ === tests/cases/compiler/file1.ts === - -No type information for this code.export default function() {} +export default function() {} No type information for this code. No type information for this code.=== tests/cases/compiler/file2.ts === export default function foo() {} diff --git a/tests/baselines/reference/systemModuleExportDefault.types b/tests/baselines/reference/systemModuleExportDefault.types index 38b5abec8edb7..a783a3d3c011c 100644 --- a/tests/baselines/reference/systemModuleExportDefault.types +++ b/tests/baselines/reference/systemModuleExportDefault.types @@ -1,6 +1,5 @@ === tests/cases/compiler/file1.ts === - -No type information for this code.export default function() {} +export default function() {} No type information for this code. No type information for this code.=== tests/cases/compiler/file2.ts === export default function foo() {} diff --git a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js index df68f32b3bd73..8337b4faea996 100644 --- a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js +++ b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.js @@ -1,5 +1,4 @@ //// [systemModuleNonTopLevelModuleMembers.ts] - export class TopLevelClass {} export module TopLevelModule {var v;} export function TopLevelFunction(): void {} diff --git a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols index e0b69c71a2fe9..b6d721d5942df 100644 --- a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols +++ b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.symbols @@ -1,33 +1,32 @@ === tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts === - export class TopLevelClass {} >TopLevelClass : Symbol(TopLevelClass, Decl(systemModuleNonTopLevelModuleMembers.ts, 0, 0)) export module TopLevelModule {var v;} ->TopLevelModule : Symbol(TopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 1, 29)) ->v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 2, 33)) +>TopLevelModule : Symbol(TopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 0, 29)) +>v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 1, 33)) export function TopLevelFunction(): void {} ->TopLevelFunction : Symbol(TopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 2, 37)) +>TopLevelFunction : Symbol(TopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 1, 37)) export enum TopLevelEnum {E} ->TopLevelEnum : Symbol(TopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 3, 43)) ->E : Symbol(TopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 4, 26)) +>TopLevelEnum : Symbol(TopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 2, 43)) +>E : Symbol(TopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 3, 26)) export module TopLevelModule2 { ->TopLevelModule2 : Symbol(TopLevelModule2, Decl(systemModuleNonTopLevelModuleMembers.ts, 4, 28)) +>TopLevelModule2 : Symbol(TopLevelModule2, Decl(systemModuleNonTopLevelModuleMembers.ts, 3, 28)) export class NonTopLevelClass {} ->NonTopLevelClass : Symbol(NonTopLevelClass, Decl(systemModuleNonTopLevelModuleMembers.ts, 6, 31)) +>NonTopLevelClass : Symbol(NonTopLevelClass, Decl(systemModuleNonTopLevelModuleMembers.ts, 5, 31)) export module NonTopLevelModule {var v;} ->NonTopLevelModule : Symbol(NonTopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 7, 36)) ->v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 8, 40)) +>NonTopLevelModule : Symbol(NonTopLevelModule, Decl(systemModuleNonTopLevelModuleMembers.ts, 6, 36)) +>v : Symbol(v, Decl(systemModuleNonTopLevelModuleMembers.ts, 7, 40)) export function NonTopLevelFunction(): void {} ->NonTopLevelFunction : Symbol(NonTopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 8, 44)) +>NonTopLevelFunction : Symbol(NonTopLevelFunction, Decl(systemModuleNonTopLevelModuleMembers.ts, 7, 44)) export enum NonTopLevelEnum {E} ->NonTopLevelEnum : Symbol(NonTopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 9, 50)) ->E : Symbol(NonTopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 10, 33)) +>NonTopLevelEnum : Symbol(NonTopLevelEnum, Decl(systemModuleNonTopLevelModuleMembers.ts, 8, 50)) +>E : Symbol(NonTopLevelEnum.E, Decl(systemModuleNonTopLevelModuleMembers.ts, 9, 33)) } diff --git a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types index ffe3d23f7a6a1..61edb6db4b002 100644 --- a/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types +++ b/tests/baselines/reference/systemModuleNonTopLevelModuleMembers.types @@ -1,5 +1,4 @@ === tests/cases/compiler/systemModuleNonTopLevelModuleMembers.ts === - export class TopLevelClass {} >TopLevelClass : TopLevelClass diff --git a/tests/baselines/reference/systemModuleWithSuperClass.js b/tests/baselines/reference/systemModuleWithSuperClass.js index 8ac8770d8b1bf..5964cb9c27f86 100644 --- a/tests/baselines/reference/systemModuleWithSuperClass.js +++ b/tests/baselines/reference/systemModuleWithSuperClass.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/systemModuleWithSuperClass.ts] //// //// [foo.ts] - export class Foo { a: string; } diff --git a/tests/baselines/reference/systemModuleWithSuperClass.symbols b/tests/baselines/reference/systemModuleWithSuperClass.symbols index 415e7d1e99f8e..0918d349ee524 100644 --- a/tests/baselines/reference/systemModuleWithSuperClass.symbols +++ b/tests/baselines/reference/systemModuleWithSuperClass.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/foo.ts === - export class Foo { >Foo : Symbol(Foo, Decl(foo.ts, 0, 0)) a: string; ->a : Symbol(Foo.a, Decl(foo.ts, 1, 18)) +>a : Symbol(Foo.a, Decl(foo.ts, 0, 18)) } === tests/cases/compiler/bar.ts === diff --git a/tests/baselines/reference/systemModuleWithSuperClass.types b/tests/baselines/reference/systemModuleWithSuperClass.types index 130f53f0ce305..b1e960984fc25 100644 --- a/tests/baselines/reference/systemModuleWithSuperClass.types +++ b/tests/baselines/reference/systemModuleWithSuperClass.types @@ -1,5 +1,4 @@ === tests/cases/compiler/foo.ts === - export class Foo { >Foo : Foo diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.js b/tests/baselines/reference/taggedTemplateContextualTyping1.js index 17618b50e8b25..852ea29d2b130 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.js +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.js @@ -1,5 +1,4 @@ //// [taggedTemplateContextualTyping1.ts] - type FuncType = (x: (p: T) => T) => typeof x; function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, x: T): T; diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols index 3c50a6f92e46c..320c0e7447927 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols @@ -1,44 +1,43 @@ === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts === - type FuncType = (x: (p: T) => T) => typeof x; >FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 1, 17)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 1, 21)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 1, 24)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 1, 21)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 1, 21)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 1, 17)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 0, 17)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 0, 21)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 0, 24)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 0, 21)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 0, 21)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 0, 17)) function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, x: T): T; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 2, 18)) +>templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 2, 21)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 2, 56)) +>FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 2, 69)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 2, 18)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 2, 18)) + +function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T; +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 3, 18)) >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 3, 21)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) >f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 3, 56)) >FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 3, 69)) +>h : Symbol(h, Decl(taggedTemplateContextualTyping1.ts, 3, 69)) +>FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 3, 82)) >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 3, 18)) >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 3, 18)) -function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 4, 18)) ->templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 4, 21)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 4, 56)) ->FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) ->h : Symbol(h, Decl(taggedTemplateContextualTyping1.ts, 4, 69)) ->FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 4, 82)) +function tempTag1(...rest: any[]): T { +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 4, 18)) +>rest : Symbol(rest, Decl(taggedTemplateContextualTyping1.ts, 4, 21)) >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 4, 18)) -function tempTag1(...rest: any[]): T { ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 5, 18)) ->rest : Symbol(rest, Decl(taggedTemplateContextualTyping1.ts, 5, 21)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 5, 18)) - return undefined; >undefined : Symbol(undefined) } @@ -48,52 +47,52 @@ function tempTag1(...rest: any[]): T { // and it is an error to invoke an any-typed value with type arguments, // so this test will error. tempTag1 `${ x => { x(undefined); return x; } }${ 10 }`; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 12, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 12, 12)) +>undefined : Symbol(undefined) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 12, 12)) + +tempTag1 `${ x => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ 10 }`; +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12)) >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12)) >undefined : Symbol(undefined) >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 13, 75)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 13, 75)) +>undefined : Symbol(undefined) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 13, 75)) -tempTag1 `${ x => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ 10 }`; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) +tempTag1 `${ x => { x(undefined); return x; } }${ (y: (p: T) => T) => { y(undefined); return y } }${ undefined }`; +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12)) >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12)) >undefined : Symbol(undefined) >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75)) ->undefined : Symbol(undefined) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75)) - -tempTag1 `${ x => { x(undefined); return x; } }${ (y: (p: T) => T) => { y(undefined); return y } }${ undefined }`; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12)) ->undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 77)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 81)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 15, 84)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 81)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 81)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 77)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 77)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 14, 81)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 14, 84)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 14, 81)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 14, 81)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 77)) >undefined : Symbol(undefined) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 77)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 77)) >undefined : Symbol(undefined) tempTag1 `${ (x: (p: T) => T) => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ undefined }`; ->tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 16, 18)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 16, 21)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 16, 18)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 16, 18)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14)) +>tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 14)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 18)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 15, 21)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 18)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 18)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 14)) >undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 14)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 75)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 75)) >undefined : Symbol(undefined) ->y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 75)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.types b/tests/baselines/reference/taggedTemplateContextualTyping1.types index 4e207a0d6bbaf..26acf1d9ba65d 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.types +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts === - type FuncType = (x: (p: T) => T) => typeof x; >FuncType : FuncType >x : (p: T) => T diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.js b/tests/baselines/reference/taggedTemplateContextualTyping2.js index 8adea53f470bc..eafeac6fab84b 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping2.js +++ b/tests/baselines/reference/taggedTemplateContextualTyping2.js @@ -1,5 +1,4 @@ //// [taggedTemplateContextualTyping2.ts] - type FuncType1 = (x: (p: T) => T) => typeof x; type FuncType2 = (x: (p: T) => T) => typeof x; diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols index a1ee63ef8b080..8c9459638d05e 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols +++ b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols @@ -1,45 +1,44 @@ === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping2.ts === - type FuncType1 = (x: (p: T) => T) => typeof x; >FuncType1 : Symbol(FuncType1, Decl(taggedTemplateContextualTyping2.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 1, 18)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 22)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping2.ts, 1, 25)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 22)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 22)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 1, 18)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 0, 18)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 0, 22)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping2.ts, 0, 25)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 0, 22)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 0, 22)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 0, 18)) type FuncType2 = (x: (p: T) => T) => typeof x; ->FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 1, 49)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 2, 18)) ->S : Symbol(S, Decl(taggedTemplateContextualTyping2.ts, 2, 22)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 2, 24)) ->p : Symbol(p, Decl(taggedTemplateContextualTyping2.ts, 2, 28)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 2, 24)) ->T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 2, 24)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 2, 18)) +>FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 0, 49)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 1, 18)) +>S : Symbol(S, Decl(taggedTemplateContextualTyping2.ts, 1, 22)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 24)) +>p : Symbol(p, Decl(taggedTemplateContextualTyping2.ts, 1, 28)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 24)) +>T : Symbol(T, Decl(taggedTemplateContextualTyping2.ts, 1, 24)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 1, 18)) function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number): number; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) ->templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 4, 18)) +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) +>templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 3, 18)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 4, 53)) +>f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 3, 53)) >FuncType1 : Symbol(FuncType1, Decl(taggedTemplateContextualTyping2.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 4, 67)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 3, 67)) function tempTag2(templateStrs: TemplateStringsArray, f: FuncType2, h: FuncType2, x: string): string; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) ->templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 5, 18)) +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) +>templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 4, 18)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 5, 53)) ->FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 1, 49)) ->h : Symbol(h, Decl(taggedTemplateContextualTyping2.ts, 5, 67)) ->FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 1, 49)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 5, 81)) +>f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 4, 53)) +>FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 0, 49)) +>h : Symbol(h, Decl(taggedTemplateContextualTyping2.ts, 4, 67)) +>FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 0, 49)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 4, 81)) function tempTag2(...rest: any[]): any { ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) ->rest : Symbol(rest, Decl(taggedTemplateContextualTyping2.ts, 6, 18)) +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) +>rest : Symbol(rest, Decl(taggedTemplateContextualTyping2.ts, 5, 18)) return undefined; >undefined : Symbol(undefined) @@ -50,27 +49,27 @@ function tempTag2(...rest: any[]): any { // and it is an error to invoke an any-typed value with type arguments, // so this test will error. tempTag2 `${ x => { x(undefined); return x; } }${ 0 }`; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 13, 12)) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 13, 12)) +>undefined : Symbol(undefined) +>x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 13, 12)) + +tempTag2 `${ x => { x(undefined); return x; } }${ y => { y(null); return y; } }${ "hello" }`; +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12)) >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12)) >undefined : Symbol(undefined) >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 14, 65)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 14, 65)) +>y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 14, 65)) -tempTag2 `${ x => { x(undefined); return x; } }${ y => { y(null); return y; } }${ "hello" }`; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) +tempTag2 `${ x => { x(undefined); return x; } }${ undefined }${ "hello" }`; +>tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101)) >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12)) >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12)) >undefined : Symbol(undefined) >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65)) ->y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65)) - -tempTag2 `${ x => { x(undefined); return x; } }${ undefined }${ "hello" }`; ->tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12)) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12)) ->undefined : Symbol(undefined) ->x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.types b/tests/baselines/reference/taggedTemplateContextualTyping2.types index 2dbf2c53c8b3b..60374853956c4 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping2.types +++ b/tests/baselines/reference/taggedTemplateContextualTyping2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping2.ts === - type FuncType1 = (x: (p: T) => T) => typeof x; >FuncType1 : FuncType1 >x : (p: T) => T diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.js b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.js index 33c2914e3e824..10610fb28a970 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.js +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts] - - function f(...x: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.symbols b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.symbols index 1d91e37ae01fb..c356f8d65bf3f 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.symbols +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.symbols @@ -1,9 +1,7 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts === - - function f(...x: any[]) { >f : Symbol(f, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts, 2, 11)) +>x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts, 0, 11)) } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.types b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.types index e40e80fe7f97c..9b394f2bceb7c 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.types +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.ts === - - function f(...x: any[]) { >f : (...x: any[]) => void >x : any[] diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.js b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.js index a3c6806b1d314..30b08ea23e200 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.js +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts] - function f(...x: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.symbols index 85d723329608f..558fe61ed8206 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts === - function f(...x: any[]) { >f : Symbol(f, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts, 1, 11)) +>x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts, 0, 11)) } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.types b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.types index 8a1c5f434a83c..775914faeeaf1 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.types +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01_ES6.ts === - function f(...x: any[]) { >f : (...x: any[]) => void >x : any[] diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js index ca192ef98d394..159181febc1c9 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.ts] - - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.js] diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.symbols b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.symbols index 3ee1a72f8e24d..d5bcee8217f62 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.symbols +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.symbols @@ -1,5 +1,3 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.ts === - -No type information for this code. -No type information for this code.`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` +`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.types b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.types index 6619696bb3900..d4b77f95c4fe8 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.types +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02.ts === - - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` >`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` : string >" " : " " diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.js b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.js index 46eb5e90cd954..1492af8fa52ab 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.js +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts] - function f(...x: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.symbols index 1d969c1d30054..43eabc71e861b 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.symbols @@ -1,8 +1,7 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts === - function f(...x: any[]) { >f : Symbol(f, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts, 1, 11)) +>x : Symbol(x, Decl(taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts, 0, 11)) } diff --git a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.types b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.types index 2fae6446989cf..dc6455c17a917 100644 --- a/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.types +++ b/tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes02_ES6.ts === - function f(...x: any[]) { >f : (...x: any[]) => void >x : any[] diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt index 2ead58862b64e..4eae70010ce6f 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt @@ -1,13 +1,11 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(64,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(62,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate '""' is not a valid type argument because it is not a supertype of candidate '0'. -tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(77,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(75,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'. Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts (2 errors) ==== - - // Generic tag with one parameter function noParams(n: T) { } noParams ``; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js index 69dcd2841832a..e0427c28b87e8 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsTypeArgumentInference.ts] - - // Generic tag with one parameter function noParams(n: T) { } noParams ``; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt index 781456b8bbbef..6a5897bedc73b 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(63,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(62,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate '""' is not a valid type argument because it is not a supertype of candidate '0'. -tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(76,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(75,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'. Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts (2 errors) ==== - // Generic tag with one parameter function noParams(n: T) { } noParams ``; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js index 3097e40c9ad67..379c7b87bcbbb 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsTypeArgumentInferenceES6.ts] - // Generic tag with one parameter function noParams(n: T) { } noParams ``; diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js index fdac55da181b5..779585ac264d8 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsWithOverloadResolution2.ts] - function foo1(strs: TemplateStringsArray, x: number): string; function foo1(strs: string[], x: number): number; function foo1(...stuff: any[]): any { diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols index 241c43c4d782a..fe66a0c1c19ae 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols @@ -1,56 +1,55 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts === - function foo1(strs: TemplateStringsArray, x: number): string; ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) ->strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 14)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) +>strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 14)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 41)) +>x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 41)) function foo1(strs: string[], x: number): number; ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) ->strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 14)) ->x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 29)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) +>strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 14)) +>x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 29)) function foo1(...stuff: any[]): any { ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) ->stuff : Symbol(stuff, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 3, 14)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) +>stuff : Symbol(stuff, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 14)) return undefined; >undefined : Symbol(undefined) } var a = foo1 `${1}`; ->a : Symbol(a, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 3)) ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) +>a : Symbol(a, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 6, 3)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) var b = foo1([], 1); ->b : Symbol(b, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 3)) ->foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) +>b : Symbol(b, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 3)) +>foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 49)) function foo2(strs: string[], x: number): number; ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) ->strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 14)) ->x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 29)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) +>strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 14)) +>x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 29)) function foo2(strs: TemplateStringsArray, x: number): string; ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) ->strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 14)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) +>strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 14)) >TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 41)) +>x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 41)) function foo2(...stuff: any[]): any { ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) ->stuff : Symbol(stuff, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 12, 14)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) +>stuff : Symbol(stuff, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 14)) return undefined; >undefined : Symbol(undefined) } var c = foo2 `${1}`; ->c : Symbol(c, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 16, 3)) ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) +>c : Symbol(c, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 15, 3)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) var d = foo2([], 1); ->d : Symbol(d, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 17, 3)) ->foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) +>d : Symbol(d, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 16, 3)) +>foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 61)) diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types index 38b2087ccbf6a..bd4c039f1f22f 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts === - function foo1(strs: TemplateStringsArray, x: number): string; >foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; } >strs : TemplateStringsArray diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt index 2248fee5ceb13..444985cb38034 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(10,9): error TS2345: Argument of type '{}' is not assignable to parameter of type 'number'. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(19,4): error TS2339: Property 'foo' does not exist on type 'Date'. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(45,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(63,9): error TS2345: Argument of type 'true' is not assignable to parameter of type 'number'. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(64,18): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string'. -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(70,18): error TS2339: Property 'toFixed' does not exist on type 'string'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(9,9): error TS2345: Argument of type '{}' is not assignable to parameter of type 'number'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(18,4): error TS2339: Property 'foo' does not exist on type 'Date'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(44,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(62,9): error TS2345: Argument of type 'true' is not assignable to parameter of type 'number'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(63,18): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(69,18): error TS2339: Property 'toFixed' does not exist on type 'string'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts (6 errors) ==== - // Ambiguous call picks the first overload in declaration order function fn1(strs: TemplateStringsArray, s: string): string; function fn1(strs: TemplateStringsArray, n: number): number; diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.js index 48c03b6d41d69..df89f2aeea791 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.js +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsWithOverloadResolution3.ts] - // Ambiguous call picks the first overload in declaration order function fn1(strs: TemplateStringsArray, s: string): string; function fn1(strs: TemplateStringsArray, n: number): number; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.js b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.js index 1c25578af2e6b..7a96d4b5e4d86 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsWithTagNamedDeclare.ts] - - function declare(x: any, ...ys: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.symbols b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.symbols index ae73d532a016c..3e9d474f6fae8 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.symbols @@ -1,10 +1,8 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagNamedDeclare.ts === - - function declare(x: any, ...ys: any[]) { >declare : Symbol(declare, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 2, 17)) ->ys : Symbol(ys, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 2, 24)) +>x : Symbol(x, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 0, 17)) +>ys : Symbol(ys, Decl(taggedTemplateStringsWithTagNamedDeclare.ts, 0, 24)) } declare `Hello ${0} world!`; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.types b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.types index b0accf616afbe..3d39c883056d8 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.types +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclare.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagNamedDeclare.ts === - - function declare(x: any, ...ys: any[]) { >declare : (x: any, ...ys: any[]) => void >x : any diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.js b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.js index cd2833f383614..1984da087a473 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsWithTagNamedDeclareES6.ts] - function declare(x: any, ...ys: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.symbols index 960a12d2357df..e1408ce3834c6 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.symbols @@ -1,9 +1,8 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagNamedDeclareES6.ts === - function declare(x: any, ...ys: any[]) { >declare : Symbol(declare, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 0, 0)) ->x : Symbol(x, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 1, 17)) ->ys : Symbol(ys, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 1, 24)) +>x : Symbol(x, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 0, 17)) +>ys : Symbol(ys, Decl(taggedTemplateStringsWithTagNamedDeclareES6.ts, 0, 24)) } declare `Hello ${0} world!`; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.types b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.types index 6e474bf3474c7..57309b399ba0d 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.types +++ b/tests/baselines/reference/taggedTemplateStringsWithTagNamedDeclareES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagNamedDeclareES6.ts === - function declare(x: any, ...ys: any[]) { >declare : (x: any, ...ys: any[]) => void >x : any diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt index 6da8d2ffce38d..ebd8383c0248f 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt @@ -1,9 +1,7 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts(6,31): error TS2322: Type '"bad"' is not assignable to type 'number'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts(4,31): error TS2322: Type '"bad"' is not assignable to type 'number'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts (1 errors) ==== - - function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js index 334f61e453d3d..3e2889ce1f35e 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js @@ -1,6 +1,4 @@ //// [taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts] - - function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt index c1d18cd6f9123..57f84840310de 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts(5,31): error TS2322: Type '"bad"' is not assignable to type 'number'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts(4,31): error TS2322: Type '"bad"' is not assignable to type 'number'. ==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts (1 errors) ==== - function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js index 7691b83b3bc3e..9597723d2e550 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js @@ -1,5 +1,4 @@ //// [taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts] - function foo(...rest: any[]) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt index a64f5379e471e..ce11c177e0395 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts(6,15): error TS1160: Unterminated template literal. +tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts(5,15): error TS1160: Unterminated template literal. ==== tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts (1 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.js b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.js index 6e286da4cfd63..9cd9f13ed673a 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt index fab10f8a88827..9386a2f975361 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts(6,4): error TS1160: Unterminated template literal. +tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts(5,4): error TS1160: Unterminated template literal. ==== tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts (1 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.js b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.js index 0de0d000c9c23..6dda64828988b 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt index 56a557e1a8c05..f68bf5c23dc5f 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts(6,17): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts(5,17): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts (1 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.js index b469776180bfb..17a5582dd8574 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions1.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt index 065cc2f4787d5..8f86e19ced985 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(6,18): error TS1109: Expression expected. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(6,21): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(5,18): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(5,21): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts (2 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.js index 5a3b933b86627..1cadc11d9d525 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions2.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt index ca306a8ad8b20..f9ec9ba0ca391 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(6,18): error TS2345: Argument of type '1' is not assignable to parameter of type 'string'. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(6,23): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(5,18): error TS2345: Argument of type '1' is not assignable to parameter of type 'string'. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(5,23): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts (2 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.js index 2a918b4edd1db..2a85c0901d459 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions3.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt index 899954584853c..cc499cb25784d 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt @@ -1,10 +1,9 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(6,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(6,24): error TS1109: Expression expected. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(6,28): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(5,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(5,24): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(5,28): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts (3 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.js index 497ee53fc5362..14bdfd4279e22 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions4.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt index a264c6bc33080..0a4f0724cc276 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(6,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(6,30): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(5,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(5,30): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts (2 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.js index eb95c8869fa06..74f3591a7d4e3 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions5.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt index a5d3f132b69e9..15bcddb003370 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(6,18): error TS2345: Argument of type '1' is not assignable to parameter of type 'string'. -tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(6,23): error TS1109: Expression expected. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(5,18): error TS2345: Argument of type '1' is not assignable to parameter of type 'string'. +tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(5,23): error TS1109: Expression expected. ==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts (2 errors) ==== - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.js b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.js index 5fb32e38905c7..9ed898a418844 100644 --- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.js +++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.js @@ -1,5 +1,4 @@ //// [taggedTemplatesWithIncompleteTemplateExpressions6.ts] - function f(x: TemplateStringsArray, y: string, z: string) { } diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01.js b/tests/baselines/reference/templateStringControlCharacterEscapes01.js index 1b129e802e3c8..66c0836d82e05 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01.js @@ -1,6 +1,4 @@ //// [templateStringControlCharacterEscapes01.ts] - - var x = `\0\x00\u0000 0 00 0000`; //// [templateStringControlCharacterEscapes01.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes01.symbols index b01d09de77640..c533cf307c0ce 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes01.ts === - - var x = `\0\x00\u0000 0 00 0000`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes01.ts, 2, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes01.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01.types b/tests/baselines/reference/templateStringControlCharacterEscapes01.types index 3d3b6801d5f3e..7bd2e89839c22 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes01.ts === - - var x = `\0\x00\u0000 0 00 0000`; >x : string >`\0\x00\u0000 0 00 0000` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.js b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.js index 9015655576c02..41e0618cdd397 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.js @@ -1,5 +1,4 @@ //// [templateStringControlCharacterEscapes01_ES6.ts] - var x = `\0\x00\u0000 0 00 0000`; //// [templateStringControlCharacterEscapes01_ES6.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.symbols index af123cfa69989..49582be8b0e8a 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes01_ES6.ts === - var x = `\0\x00\u0000 0 00 0000`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes01_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes01_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.types b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.types index 6744a6e77004f..80962ecdd6a7c 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes01_ES6.ts === - var x = `\0\x00\u0000 0 00 0000`; >x : string >`\0\x00\u0000 0 00 0000` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02.js b/tests/baselines/reference/templateStringControlCharacterEscapes02.js index 5b5d34dae021d..d8d7a9008c517 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02.js @@ -1,6 +1,4 @@ //// [templateStringControlCharacterEscapes02.ts] - - var x = `\x19\u0019 19`; //// [templateStringControlCharacterEscapes02.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes02.symbols index e780fc6a41a73..926faee625d14 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes02.ts === - - var x = `\x19\u0019 19`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes02.ts, 2, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes02.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02.types b/tests/baselines/reference/templateStringControlCharacterEscapes02.types index 9be908cc7b797..4656be748ec77 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes02.ts === - - var x = `\x19\u0019 19`; >x : string >`\x19\u0019 19` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.js b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.js index 2d76674b4dd1e..aa998405cbf47 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.js @@ -1,5 +1,4 @@ //// [templateStringControlCharacterEscapes02_ES6.ts] - var x = `\x19\u0019 19`; //// [templateStringControlCharacterEscapes02_ES6.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.symbols index 9ee135228522b..8bf84cb6855dc 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes02_ES6.ts === - var x = `\x19\u0019 19`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes02_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes02_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.types b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.types index 72116686d6257..d50196f59136d 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes02_ES6.ts === - var x = `\x19\u0019 19`; >x : string >`\x19\u0019 19` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03.js b/tests/baselines/reference/templateStringControlCharacterEscapes03.js index a0e87fc7e0ea4..32eabd844ce00 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03.js @@ -1,6 +1,4 @@ //// [templateStringControlCharacterEscapes03.ts] - - var x = `\x1F\u001f 1F 1f`; //// [templateStringControlCharacterEscapes03.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes03.symbols index d029ee806be7d..154b51509e8bc 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes03.ts === - - var x = `\x1F\u001f 1F 1f`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes03.ts, 2, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes03.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03.types b/tests/baselines/reference/templateStringControlCharacterEscapes03.types index b2a944b2c2144..b509b2ccd6cd6 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes03.ts === - - var x = `\x1F\u001f 1F 1f`; >x : string >`\x1F\u001f 1F 1f` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.js b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.js index b9b3df266d97d..b13d7d5387521 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.js @@ -1,5 +1,4 @@ //// [templateStringControlCharacterEscapes03_ES6.ts] - var x = `\x1F\u001f 1F 1f`; //// [templateStringControlCharacterEscapes03_ES6.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.symbols index 16bb0fbc1e23b..da84a1c59516a 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes03_ES6.ts === - var x = `\x1F\u001f 1F 1f`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes03_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes03_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.types b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.types index ac296c10cdb97..4d35fe85c41e0 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes03_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes03_ES6.ts === - var x = `\x1F\u001f 1F 1f`; >x : string >`\x1F\u001f 1F 1f` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04.js b/tests/baselines/reference/templateStringControlCharacterEscapes04.js index 70636a584b439..19090f58dbd30 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04.js @@ -1,6 +1,4 @@ //// [templateStringControlCharacterEscapes04.ts] - - var x = `\x20\u0020 20`; //// [templateStringControlCharacterEscapes04.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes04.symbols index 168c30a55f74e..1dc8109d3fd19 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes04.ts === - - var x = `\x20\u0020 20`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes04.ts, 2, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes04.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04.types b/tests/baselines/reference/templateStringControlCharacterEscapes04.types index 07a674840fcda..ca72e253d562b 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes04.ts === - - var x = `\x20\u0020 20`; >x : string >`\x20\u0020 20` : string diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.js b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.js index 17461fb084188..4e097420caf40 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.js +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.js @@ -1,5 +1,4 @@ //// [templateStringControlCharacterEscapes04_ES6.ts] - var x = `\x20\u0020 20`; //// [templateStringControlCharacterEscapes04_ES6.js] diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.symbols b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.symbols index 040573ed76e0b..ac4a253f5fa34 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.symbols +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes04_ES6.ts === - var x = `\x20\u0020 20`; ->x : Symbol(x, Decl(templateStringControlCharacterEscapes04_ES6.ts, 1, 3)) +>x : Symbol(x, Decl(templateStringControlCharacterEscapes04_ES6.ts, 0, 3)) diff --git a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.types b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.types index 5f1c1dab862c2..01b3f35ba9abe 100644 --- a/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.types +++ b/tests/baselines/reference/templateStringControlCharacterEscapes04_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringControlCharacterEscapes04_ES6.ts === - var x = `\x20\u0020 20`; >x : string >`\x20\u0020 20` : string diff --git a/tests/baselines/reference/templateStringMultiline1.js b/tests/baselines/reference/templateStringMultiline1.js index e81cb89926a79..dabb9ae93e352 100644 --- a/tests/baselines/reference/templateStringMultiline1.js +++ b/tests/baselines/reference/templateStringMultiline1.js @@ -1,6 +1,4 @@ //// [templateStringMultiline1.ts] - - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline1.symbols b/tests/baselines/reference/templateStringMultiline1.symbols index 3b169c1b1cbbe..ae52ffeb1fd36 100644 --- a/tests/baselines/reference/templateStringMultiline1.symbols +++ b/tests/baselines/reference/templateStringMultiline1.symbols @@ -1,7 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline1.ts === - -No type information for this code. -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline1.types b/tests/baselines/reference/templateStringMultiline1.types index 521d2a8382f68..f66dd89a7bc19 100644 --- a/tests/baselines/reference/templateStringMultiline1.types +++ b/tests/baselines/reference/templateStringMultiline1.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline1.ts === - - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline1_ES6.js b/tests/baselines/reference/templateStringMultiline1_ES6.js index a44df4d0cc31a..dfc6d59ecf7ed 100644 --- a/tests/baselines/reference/templateStringMultiline1_ES6.js +++ b/tests/baselines/reference/templateStringMultiline1_ES6.js @@ -1,5 +1,4 @@ //// [templateStringMultiline1_ES6.ts] - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline1_ES6.symbols b/tests/baselines/reference/templateStringMultiline1_ES6.symbols index 5e4716ac607e2..430db1604906d 100644 --- a/tests/baselines/reference/templateStringMultiline1_ES6.symbols +++ b/tests/baselines/reference/templateStringMultiline1_ES6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline1_ES6.ts === - -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline1_ES6.types b/tests/baselines/reference/templateStringMultiline1_ES6.types index 36e60c240f918..71e82a2e5c54b 100644 --- a/tests/baselines/reference/templateStringMultiline1_ES6.types +++ b/tests/baselines/reference/templateStringMultiline1_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline1_ES6.ts === - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline2.js b/tests/baselines/reference/templateStringMultiline2.js index a87e506f07dac..df22de5fdee8a 100644 --- a/tests/baselines/reference/templateStringMultiline2.js +++ b/tests/baselines/reference/templateStringMultiline2.js @@ -1,6 +1,4 @@ //// [templateStringMultiline2.ts] - - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline2.symbols b/tests/baselines/reference/templateStringMultiline2.symbols index b4b341416c9b7..46007aa9115ae 100644 --- a/tests/baselines/reference/templateStringMultiline2.symbols +++ b/tests/baselines/reference/templateStringMultiline2.symbols @@ -1,7 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline2.ts === - -No type information for this code. -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline2.types b/tests/baselines/reference/templateStringMultiline2.types index 97f7f1bd57726..6184cb098b6a2 100644 --- a/tests/baselines/reference/templateStringMultiline2.types +++ b/tests/baselines/reference/templateStringMultiline2.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline2.ts === - - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline2_ES6.js b/tests/baselines/reference/templateStringMultiline2_ES6.js index 168c8bac39b6b..44b4265193795 100644 --- a/tests/baselines/reference/templateStringMultiline2_ES6.js +++ b/tests/baselines/reference/templateStringMultiline2_ES6.js @@ -1,5 +1,4 @@ //// [templateStringMultiline2_ES6.ts] - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline2_ES6.symbols b/tests/baselines/reference/templateStringMultiline2_ES6.symbols index 288191d3d0f09..ee01d641f9e82 100644 --- a/tests/baselines/reference/templateStringMultiline2_ES6.symbols +++ b/tests/baselines/reference/templateStringMultiline2_ES6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline2_ES6.ts === - -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline2_ES6.types b/tests/baselines/reference/templateStringMultiline2_ES6.types index e05b245cfc7c9..3d123975330b6 100644 --- a/tests/baselines/reference/templateStringMultiline2_ES6.types +++ b/tests/baselines/reference/templateStringMultiline2_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline2_ES6.ts === - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline3.js b/tests/baselines/reference/templateStringMultiline3.js index bff65582515f0..31e59af26a813 100644 --- a/tests/baselines/reference/templateStringMultiline3.js +++ b/tests/baselines/reference/templateStringMultiline3.js @@ -1,6 +1,4 @@ //// [templateStringMultiline3.ts] - - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline3.symbols b/tests/baselines/reference/templateStringMultiline3.symbols index a0e1f6f887197..73f891399fe5e 100644 --- a/tests/baselines/reference/templateStringMultiline3.symbols +++ b/tests/baselines/reference/templateStringMultiline3.symbols @@ -1,7 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline3.ts === - -No type information for this code. -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline3.types b/tests/baselines/reference/templateStringMultiline3.types index d059e2fc146e3..1d77fca9c5656 100644 --- a/tests/baselines/reference/templateStringMultiline3.types +++ b/tests/baselines/reference/templateStringMultiline3.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline3.ts === - - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringMultiline3_ES6.js b/tests/baselines/reference/templateStringMultiline3_ES6.js index aad544c13bb3d..374144c83a93c 100644 --- a/tests/baselines/reference/templateStringMultiline3_ES6.js +++ b/tests/baselines/reference/templateStringMultiline3_ES6.js @@ -1,5 +1,4 @@ //// [templateStringMultiline3_ES6.ts] - // newlines are ` \ diff --git a/tests/baselines/reference/templateStringMultiline3_ES6.symbols b/tests/baselines/reference/templateStringMultiline3_ES6.symbols index e4fa8a7edf4bf..8830da716ec4c 100644 --- a/tests/baselines/reference/templateStringMultiline3_ES6.symbols +++ b/tests/baselines/reference/templateStringMultiline3_ES6.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringMultiline3_ES6.ts === - -No type information for this code.// newlines are +// newlines are No type information for this code.` No type information for this code.\ No type information for this code.` diff --git a/tests/baselines/reference/templateStringMultiline3_ES6.types b/tests/baselines/reference/templateStringMultiline3_ES6.types index 5cb97d1b8b4c9..a1a696ebcfdc8 100644 --- a/tests/baselines/reference/templateStringMultiline3_ES6.types +++ b/tests/baselines/reference/templateStringMultiline3_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringMultiline3_ES6.ts === - // newlines are ` >`\` : string diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.js b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.js index 62629f3284f2a..44984d5ef9bb2 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.js +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.js @@ -1,5 +1,4 @@ //// [templateStringPlainCharactersThatArePartsOfEscapes01.ts] - `0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` //// [templateStringPlainCharactersThatArePartsOfEscapes01.js] diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.symbols b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.symbols index 2b77345f8ffac..71db8407b4b76 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.symbols +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes01.ts === - -No type information for this code.`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` +`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.types b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.types index e64394e106f65..acdf7898b7122 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.types +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes01.ts === - `0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` >`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` : string diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js index 4b599ee1d55b1..bf17386d9e7f5 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js @@ -1,5 +1,4 @@ //// [templateStringPlainCharactersThatArePartsOfEscapes01_ES6.ts] - `0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` //// [templateStringPlainCharactersThatArePartsOfEscapes01_ES6.js] diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.symbols b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.symbols index 33c8839e194c6..afe79fd9e2c2f 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.symbols +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.ts === - -No type information for this code.`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` +`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.types b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.types index 0f49547ba701e..110676b704b65 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.types +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes01_ES6.ts === - `0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` >`0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2028 2029 0085 t v f b r n` : string diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.js b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.js index 27090032ab93a..cc7b26dec83c0 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.js +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.js @@ -1,6 +1,4 @@ //// [templateStringPlainCharactersThatArePartsOfEscapes02.ts] - - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` //// [templateStringPlainCharactersThatArePartsOfEscapes02.js] diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.symbols b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.symbols index f630d9e71e633..efc0e021f4659 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.symbols +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.symbols @@ -1,5 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes02.ts === - -No type information for this code. -No type information for this code.`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` +`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.types b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.types index 62d0190586a2b..7d78d7f29fb65 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.types +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes02.ts === - - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` >`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` : string >" " : " " diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js index 0924c35b6ce17..58fb198265f0e 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js @@ -1,5 +1,4 @@ //// [templateStringPlainCharactersThatArePartsOfEscapes02_ES6.ts] - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` //// [templateStringPlainCharactersThatArePartsOfEscapes02_ES6.js] diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.symbols b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.symbols index 934e0fc495cd1..927efffb2b5a6 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.symbols +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.ts === - -No type information for this code.`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` +`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.types b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.types index cf07cae5b93fa..ee2b0b3600d34 100644 --- a/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.types +++ b/tests/baselines/reference/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringPlainCharactersThatArePartsOfEscapes02_ES6.ts === - `0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` >`0${ " " }1${ " " }2${ " " }3${ " " }4${ " " }5${ " " }6${ " " }7${ " " }8${ " " }9${ " " }10${ " " }11${ " " }12${ " " }13${ " " }14${ " " }15${ " " }16${ " " }17${ " " }18${ " " }19${ " " }20${ " " }2028${ " " }2029${ " " }0085${ " " }t${ " " }v${ " " }f${ " " }b${ " " }r${ " " }n` : string >" " : " " diff --git a/tests/baselines/reference/templateStringTermination1.js b/tests/baselines/reference/templateStringTermination1.js index 2243871f9aeff..cbf855244788b 100644 --- a/tests/baselines/reference/templateStringTermination1.js +++ b/tests/baselines/reference/templateStringTermination1.js @@ -1,5 +1,4 @@ //// [templateStringTermination1.ts] - `` //// [templateStringTermination1.js] diff --git a/tests/baselines/reference/templateStringTermination1.symbols b/tests/baselines/reference/templateStringTermination1.symbols index 5c3cf73af4545..966d093970499 100644 --- a/tests/baselines/reference/templateStringTermination1.symbols +++ b/tests/baselines/reference/templateStringTermination1.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination1.ts === - -No type information for this code.`` +`` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination1.types b/tests/baselines/reference/templateStringTermination1.types index bdfa46ec46c92..fa40007c96a22 100644 --- a/tests/baselines/reference/templateStringTermination1.types +++ b/tests/baselines/reference/templateStringTermination1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination1.ts === - `` >`` : string diff --git a/tests/baselines/reference/templateStringTermination2.js b/tests/baselines/reference/templateStringTermination2.js index 37fd3ffd6f9a1..6e199e89a8a9a 100644 --- a/tests/baselines/reference/templateStringTermination2.js +++ b/tests/baselines/reference/templateStringTermination2.js @@ -1,5 +1,4 @@ //// [templateStringTermination2.ts] - `\\` //// [templateStringTermination2.js] diff --git a/tests/baselines/reference/templateStringTermination2.symbols b/tests/baselines/reference/templateStringTermination2.symbols index 927f257c21f72..4593ef347f45b 100644 --- a/tests/baselines/reference/templateStringTermination2.symbols +++ b/tests/baselines/reference/templateStringTermination2.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination2.ts === - -No type information for this code.`\\` +`\\` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination2.types b/tests/baselines/reference/templateStringTermination2.types index d5e6f9e15a96b..205cb1e620a1e 100644 --- a/tests/baselines/reference/templateStringTermination2.types +++ b/tests/baselines/reference/templateStringTermination2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination2.ts === - `\\` >`\\` : string diff --git a/tests/baselines/reference/templateStringTermination3.js b/tests/baselines/reference/templateStringTermination3.js index 1bb2c2ab00784..6ab2a4a9fe8af 100644 --- a/tests/baselines/reference/templateStringTermination3.js +++ b/tests/baselines/reference/templateStringTermination3.js @@ -1,5 +1,4 @@ //// [templateStringTermination3.ts] - `\`` //// [templateStringTermination3.js] diff --git a/tests/baselines/reference/templateStringTermination3.symbols b/tests/baselines/reference/templateStringTermination3.symbols index a59aef6bfeade..1e23b4e1eae8c 100644 --- a/tests/baselines/reference/templateStringTermination3.symbols +++ b/tests/baselines/reference/templateStringTermination3.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination3.ts === - -No type information for this code.`\`` +`\`` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination3.types b/tests/baselines/reference/templateStringTermination3.types index 0338dbf4c84ff..bdb09e00dc3a5 100644 --- a/tests/baselines/reference/templateStringTermination3.types +++ b/tests/baselines/reference/templateStringTermination3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination3.ts === - `\`` >`\`` : string diff --git a/tests/baselines/reference/templateStringTermination4.js b/tests/baselines/reference/templateStringTermination4.js index 29bbe4e9316a4..e9f4086c7a4f6 100644 --- a/tests/baselines/reference/templateStringTermination4.js +++ b/tests/baselines/reference/templateStringTermination4.js @@ -1,5 +1,4 @@ //// [templateStringTermination4.ts] - `\\\\` //// [templateStringTermination4.js] diff --git a/tests/baselines/reference/templateStringTermination4.symbols b/tests/baselines/reference/templateStringTermination4.symbols index ecf2ad9749f23..294db6fec548f 100644 --- a/tests/baselines/reference/templateStringTermination4.symbols +++ b/tests/baselines/reference/templateStringTermination4.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination4.ts === - -No type information for this code.`\\\\` +`\\\\` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination4.types b/tests/baselines/reference/templateStringTermination4.types index da45817ddd02a..35a330148587e 100644 --- a/tests/baselines/reference/templateStringTermination4.types +++ b/tests/baselines/reference/templateStringTermination4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination4.ts === - `\\\\` >`\\\\` : string diff --git a/tests/baselines/reference/templateStringTermination5.js b/tests/baselines/reference/templateStringTermination5.js index 769597f520935..f4bbd535d0859 100644 --- a/tests/baselines/reference/templateStringTermination5.js +++ b/tests/baselines/reference/templateStringTermination5.js @@ -1,5 +1,4 @@ //// [templateStringTermination5.ts] - `\\\\\\` //// [templateStringTermination5.js] diff --git a/tests/baselines/reference/templateStringTermination5.symbols b/tests/baselines/reference/templateStringTermination5.symbols index 8ae94a1803811..a1a51f1e4388f 100644 --- a/tests/baselines/reference/templateStringTermination5.symbols +++ b/tests/baselines/reference/templateStringTermination5.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringTermination5.ts === - -No type information for this code.`\\\\\\` +`\\\\\\` No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringTermination5.types b/tests/baselines/reference/templateStringTermination5.types index 87641ff229832..34c6cf9fb82e2 100644 --- a/tests/baselines/reference/templateStringTermination5.types +++ b/tests/baselines/reference/templateStringTermination5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringTermination5.ts === - `\\\\\\` >`\\\\\\` : string diff --git a/tests/baselines/reference/templateStringUnterminated1.errors.txt b/tests/baselines/reference/templateStringUnterminated1.errors.txt index 3353c062448c6..7bc3db7a09e02 100644 --- a/tests/baselines/reference/templateStringUnterminated1.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated1.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated1.ts(2,2): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated1.ts(1,2): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated1.ts (1 errors) ==== - ` !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated1.js b/tests/baselines/reference/templateStringUnterminated1.js index 0450f1f982c56..19ec7a400f734 100644 --- a/tests/baselines/reference/templateStringUnterminated1.js +++ b/tests/baselines/reference/templateStringUnterminated1.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated1.ts] - ` //// [templateStringUnterminated1.js] diff --git a/tests/baselines/reference/templateStringUnterminated2.errors.txt b/tests/baselines/reference/templateStringUnterminated2.errors.txt index 0fd78e097b00d..a8e873fcb08b3 100644 --- a/tests/baselines/reference/templateStringUnterminated2.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated2.ts(2,4): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated2.ts(1,4): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated2.ts (1 errors) ==== - `\` !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated2.js b/tests/baselines/reference/templateStringUnterminated2.js index 2c6b113e9eb61..16b7dc541db4b 100644 --- a/tests/baselines/reference/templateStringUnterminated2.js +++ b/tests/baselines/reference/templateStringUnterminated2.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated2.ts] - `\` //// [templateStringUnterminated2.js] diff --git a/tests/baselines/reference/templateStringUnterminated3.errors.txt b/tests/baselines/reference/templateStringUnterminated3.errors.txt index 1b25de284dae1..2a7a5c6bb9c34 100644 --- a/tests/baselines/reference/templateStringUnterminated3.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated3.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated3.ts(2,4): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated3.ts(1,4): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated3.ts (1 errors) ==== - `\\ !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated3.js b/tests/baselines/reference/templateStringUnterminated3.js index 575b6122abfb3..bb0d7f4b740b2 100644 --- a/tests/baselines/reference/templateStringUnterminated3.js +++ b/tests/baselines/reference/templateStringUnterminated3.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated3.ts] - `\\ //// [templateStringUnterminated3.js] diff --git a/tests/baselines/reference/templateStringUnterminated4.errors.txt b/tests/baselines/reference/templateStringUnterminated4.errors.txt index 8eb41921187ad..ae9724546596c 100644 --- a/tests/baselines/reference/templateStringUnterminated4.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated4.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated4.ts(2,6): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated4.ts(1,6): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated4.ts (1 errors) ==== - `\\\` !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated4.js b/tests/baselines/reference/templateStringUnterminated4.js index e94fe566a07f6..59059eaf8b9a7 100644 --- a/tests/baselines/reference/templateStringUnterminated4.js +++ b/tests/baselines/reference/templateStringUnterminated4.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated4.ts] - `\\\` //// [templateStringUnterminated4.js] diff --git a/tests/baselines/reference/templateStringUnterminated5.errors.txt b/tests/baselines/reference/templateStringUnterminated5.errors.txt index 20fd54e81123b..c9e42252a924d 100644 --- a/tests/baselines/reference/templateStringUnterminated5.errors.txt +++ b/tests/baselines/reference/templateStringUnterminated5.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringUnterminated5.ts(2,8): error TS1160: Unterminated template literal. +tests/cases/conformance/es6/templates/templateStringUnterminated5.ts(1,8): error TS1160: Unterminated template literal. ==== tests/cases/conformance/es6/templates/templateStringUnterminated5.ts (1 errors) ==== - `\\\\\` !!! error TS1160: Unterminated template literal. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringUnterminated5.js b/tests/baselines/reference/templateStringUnterminated5.js index bee0b2dcd36e5..f4e3b58be2314 100644 --- a/tests/baselines/reference/templateStringUnterminated5.js +++ b/tests/baselines/reference/templateStringUnterminated5.js @@ -1,5 +1,4 @@ //// [templateStringUnterminated5.ts] - `\\\\\` //// [templateStringUnterminated5.js] diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1.js b/tests/baselines/reference/templateStringWhitespaceEscapes1.js index 1edd38c315b98..5538af147786c 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1.js +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1.js @@ -1,6 +1,4 @@ //// [templateStringWhitespaceEscapes1.ts] - - `\t\n\v\f\r`; //// [templateStringWhitespaceEscapes1.js] diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1.symbols b/tests/baselines/reference/templateStringWhitespaceEscapes1.symbols index 6c1598e054928..da8fe8ad0d6f0 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1.symbols +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1.symbols @@ -1,5 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes1.ts === - -No type information for this code. -No type information for this code.`\t\n\v\f\r`; +`\t\n\v\f\r`; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1.types b/tests/baselines/reference/templateStringWhitespaceEscapes1.types index 1aa3d2b49242d..e554f45685b09 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1.types +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes1.ts === - - `\t\n\v\f\r`; >`\t\n\v\f\r` : string diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.js b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.js index 55b93bd68a67a..1996df5e19390 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.js +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.js @@ -1,5 +1,4 @@ //// [templateStringWhitespaceEscapes1_ES6.ts] - `\t\n\v\f\r`; //// [templateStringWhitespaceEscapes1_ES6.js] diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.symbols b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.symbols index 53a6c6f9cf974..a7f9afeb1266e 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.symbols +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.symbols @@ -1,4 +1,3 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes1_ES6.ts === - -No type information for this code.`\t\n\v\f\r`; +`\t\n\v\f\r`; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.types b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.types index 25e0134afbeb3..3888c1be0684c 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.types +++ b/tests/baselines/reference/templateStringWhitespaceEscapes1_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes1_ES6.ts === - `\t\n\v\f\r`; >`\t\n\v\f\r` : string diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2.js b/tests/baselines/reference/templateStringWhitespaceEscapes2.js index 1a46cc7f75079..4ac2c01d462f8 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2.js +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2.js @@ -1,6 +1,4 @@ //// [templateStringWhitespaceEscapes2.ts] - - // , , , , , `\u0009\u000B\u000C\u0020\u00A0\uFEFF`; diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2.symbols b/tests/baselines/reference/templateStringWhitespaceEscapes2.symbols index 7c7de875379d3..6636b624222f8 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2.symbols +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2.symbols @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes2.ts === - -No type information for this code. -No type information for this code.// , , , , , +// , , , , , No type information for this code.`\u0009\u000B\u000C\u0020\u00A0\uFEFF`; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2.types b/tests/baselines/reference/templateStringWhitespaceEscapes2.types index 14f029cf999f4..3a43fe5e5a2a0 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2.types +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes2.ts === - - // , , , , , `\u0009\u000B\u000C\u0020\u00A0\uFEFF`; >`\u0009\u000B\u000C\u0020\u00A0\uFEFF` : string diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.js b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.js index bf901c5e8431e..39709078ef75d 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.js +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.js @@ -1,5 +1,4 @@ //// [templateStringWhitespaceEscapes2_ES6.ts] - // , , , , , `\u0009\u000B\u000C\u0020\u00A0\uFEFF`; diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.symbols b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.symbols index 834ce22cc32af..b8c4fb82a3e0e 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.symbols +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes2_ES6.ts === - -No type information for this code.// , , , , , +// , , , , , No type information for this code.`\u0009\u000B\u000C\u0020\u00A0\uFEFF`; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.types b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.types index ff509c1913f4d..1627945e1c4f6 100644 --- a/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.types +++ b/tests/baselines/reference/templateStringWhitespaceEscapes2_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWhitespaceEscapes2_ES6.ts === - // , , , , , `\u0009\u000B\u000C\u0020\u00A0\uFEFF`; >`\u0009\u000B\u000C\u0020\u00A0\uFEFF` : string diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01.js b/tests/baselines/reference/templateStringWithBackslashEscapes01.js index add1fdd917187..d304cc5a69be4 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01.js +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01.js @@ -1,6 +1,4 @@ //// [templateStringWithBackslashEscapes01.ts] - - var a = `hello\world`; var b = `hello\\world`; var c = `hello\\\world`; diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01.symbols b/tests/baselines/reference/templateStringWithBackslashEscapes01.symbols index 3c706afea5fa0..17411f75db7a8 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01.symbols +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01.symbols @@ -1,15 +1,13 @@ === tests/cases/conformance/es6/templates/templateStringWithBackslashEscapes01.ts === - - var a = `hello\world`; ->a : Symbol(a, Decl(templateStringWithBackslashEscapes01.ts, 2, 3)) +>a : Symbol(a, Decl(templateStringWithBackslashEscapes01.ts, 0, 3)) var b = `hello\\world`; ->b : Symbol(b, Decl(templateStringWithBackslashEscapes01.ts, 3, 3)) +>b : Symbol(b, Decl(templateStringWithBackslashEscapes01.ts, 1, 3)) var c = `hello\\\world`; ->c : Symbol(c, Decl(templateStringWithBackslashEscapes01.ts, 4, 3)) +>c : Symbol(c, Decl(templateStringWithBackslashEscapes01.ts, 2, 3)) var d = `hello\\\\world`; ->d : Symbol(d, Decl(templateStringWithBackslashEscapes01.ts, 5, 3)) +>d : Symbol(d, Decl(templateStringWithBackslashEscapes01.ts, 3, 3)) diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01.types b/tests/baselines/reference/templateStringWithBackslashEscapes01.types index 58f923dca54ca..e65c751b9d4f9 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01.types +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01.types @@ -1,6 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWithBackslashEscapes01.ts === - - var a = `hello\world`; >a : string >`hello\world` : string diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.js b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.js index 3b5f1e2c14e78..684ef0591aa85 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.js +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.js @@ -1,5 +1,4 @@ //// [templateStringWithBackslashEscapes01_ES6.ts] - var a = `hello\world`; var b = `hello\\world`; var c = `hello\\\world`; diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.symbols b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.symbols index c5ccef88d5a44..32c7bd2e684eb 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.symbols +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/es6/templates/templateStringWithBackslashEscapes01_ES6.ts === - var a = `hello\world`; ->a : Symbol(a, Decl(templateStringWithBackslashEscapes01_ES6.ts, 1, 3)) +>a : Symbol(a, Decl(templateStringWithBackslashEscapes01_ES6.ts, 0, 3)) var b = `hello\\world`; ->b : Symbol(b, Decl(templateStringWithBackslashEscapes01_ES6.ts, 2, 3)) +>b : Symbol(b, Decl(templateStringWithBackslashEscapes01_ES6.ts, 1, 3)) var c = `hello\\\world`; ->c : Symbol(c, Decl(templateStringWithBackslashEscapes01_ES6.ts, 3, 3)) +>c : Symbol(c, Decl(templateStringWithBackslashEscapes01_ES6.ts, 2, 3)) var d = `hello\\\\world`; ->d : Symbol(d, Decl(templateStringWithBackslashEscapes01_ES6.ts, 4, 3)) +>d : Symbol(d, Decl(templateStringWithBackslashEscapes01_ES6.ts, 3, 3)) diff --git a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.types b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.types index 7d158dd14f4d7..9d1622609beb2 100644 --- a/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.types +++ b/tests/baselines/reference/templateStringWithBackslashEscapes01_ES6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es6/templates/templateStringWithBackslashEscapes01_ES6.ts === - var a = `hello\world`; >a : string >`hello\world` : string diff --git a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt index 94ab502864775..2c11f638a8abf 100644 --- a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(7,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. ==== tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts (1 errors) ==== - class TemplateStringsArray { } diff --git a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.js b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.js index 1ebc479593dab..7c8beb428c83d 100644 --- a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.js +++ b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.js @@ -1,5 +1,4 @@ //// [templateStringsArrayTypeDefinedInES5Mode.ts] - class TemplateStringsArray { } diff --git a/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.errors.txt index 1201c82f4d07b..26063c45a0f68 100644 --- a/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/templateStringsArrayTypeNotDefinedES5Mode.ts(5,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/compiler/templateStringsArrayTypeNotDefinedES5Mode.ts(4,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. ==== tests/cases/compiler/templateStringsArrayTypeNotDefinedES5Mode.ts (1 errors) ==== - function f(x: TemplateStringsArray, y: number, z: number) { } diff --git a/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.js b/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.js index 69d61d7955461..6daa46d037b5c 100644 --- a/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.js +++ b/tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.js @@ -1,5 +1,4 @@ //// [templateStringsArrayTypeNotDefinedES5Mode.ts] - function f(x: TemplateStringsArray, y: number, z: number) { } diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt index f410d40848231..c1bb393c2137a 100644 --- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt @@ -1,9 +1,8 @@ -tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(7,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. ==== tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts (1 errors) ==== - class TemplateStringsArray { } diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.js b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.js index 95ab43743aecf..4fc3b2fcf3360 100644 --- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.js +++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.js @@ -1,5 +1,4 @@ //// [templateStringsArrayTypeRedefinedInES6Mode.ts] - class TemplateStringsArray { } diff --git a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt index 6b11fdb661a5b..402b32846998f 100644 --- a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt +++ b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.errors.txt @@ -1,9 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts(3,27): error TS2322: Type '"bad"' is not assignable to type 'number'. +tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts(1,27): error TS2322: Type '"bad"' is not assignable to type 'number'. ==== tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts (1 errors) ==== - - `${function (x: number) { x = "bad"; } }`; ~ !!! error TS2322: Type '"bad"' is not assignable to type 'number'. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js index 72d0fd8c8dbd7..f01741ce68d6b 100644 --- a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js +++ b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js @@ -1,6 +1,4 @@ //// [templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.ts] - - `${function (x: number) { x = "bad"; } }`; //// [templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.js] diff --git a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt index 8d5a8bb48850a..f225154aab5f9 100644 --- a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt +++ b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts(2,27): error TS2322: Type '"bad"' is not assignable to type 'number'. +tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts(1,27): error TS2322: Type '"bad"' is not assignable to type 'number'. ==== tests/cases/conformance/es6/templates/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts (1 errors) ==== - `${function (x: number) { x = "bad"; } }`; ~ !!! error TS2322: Type '"bad"' is not assignable to type 'number'. \ No newline at end of file diff --git a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js index 18fae66c78a88..a549dc94e3d84 100644 --- a/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js +++ b/tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js @@ -1,5 +1,4 @@ //// [templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.ts] - `${function (x: number) { x = "bad"; } }`; //// [templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.js] diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.js b/tests/baselines/reference/ternaryExpressionSourceMap.js index 4b43726b2810e..4fa12f10bd432 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.js +++ b/tests/baselines/reference/ternaryExpressionSourceMap.js @@ -1,5 +1,4 @@ //// [ternaryExpressionSourceMap.ts] - var x = 1; var foo = x ? () => 0 : () => 0; diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.js.map b/tests/baselines/reference/ternaryExpressionSourceMap.js.map index f7ddfe9024c5b..9340c972274f0 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.js.map +++ b/tests/baselines/reference/ternaryExpressionSourceMap.js.map @@ -1,2 +1,2 @@ //// [ternaryExpressionSourceMap.js.map] -{"version":3,"file":"ternaryExpressionSourceMap.js","sourceRoot":"","sources":["ternaryExpressionSourceMap.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,IAAI,GAAG,GAAG,CAAC,GAAG,cAAM,OAAA,CAAC,EAAD,CAAC,GAAG,cAAM,OAAA,CAAC,EAAD,CAAC,CAAC"} \ No newline at end of file +{"version":3,"file":"ternaryExpressionSourceMap.js","sourceRoot":"","sources":["ternaryExpressionSourceMap.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,CAAC,CAAC;AACV,IAAI,GAAG,GAAG,CAAC,GAAG,cAAM,OAAA,CAAC,EAAD,CAAC,GAAG,cAAM,OAAA,CAAC,EAAD,CAAC,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.sourcemap.txt b/tests/baselines/reference/ternaryExpressionSourceMap.sourcemap.txt index 51807286b632e..d46e703e3570d 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.sourcemap.txt +++ b/tests/baselines/reference/ternaryExpressionSourceMap.sourcemap.txt @@ -16,19 +16,18 @@ sourceFile:ternaryExpressionSourceMap.ts 5 > ^ 6 > ^ 7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > +1 > 2 >var 3 > x 4 > = 5 > 1 6 > ; -1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0) -3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0) -4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0) -5 >Emitted(1, 10) Source(2, 10) + SourceIndex(0) -6 >Emitted(1, 11) Source(2, 11) + SourceIndex(0) +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0) +3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0) +4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0) +5 >Emitted(1, 10) Source(1, 10) + SourceIndex(0) +6 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) --- >>>var foo = x ? function () { return 0; } : function () { return 0; }; 1-> @@ -68,23 +67,23 @@ sourceFile:ternaryExpressionSourceMap.ts 16> 17> 0 18> ; -1->Emitted(2, 1) Source(3, 1) + SourceIndex(0) -2 >Emitted(2, 5) Source(3, 5) + SourceIndex(0) -3 >Emitted(2, 8) Source(3, 8) + SourceIndex(0) -4 >Emitted(2, 11) Source(3, 11) + SourceIndex(0) -5 >Emitted(2, 12) Source(3, 12) + SourceIndex(0) -6 >Emitted(2, 15) Source(3, 15) + SourceIndex(0) -7 >Emitted(2, 29) Source(3, 21) + SourceIndex(0) -8 >Emitted(2, 36) Source(3, 21) + SourceIndex(0) -9 >Emitted(2, 37) Source(3, 22) + SourceIndex(0) -10>Emitted(2, 39) Source(3, 21) + SourceIndex(0) -11>Emitted(2, 40) Source(3, 22) + SourceIndex(0) -12>Emitted(2, 43) Source(3, 25) + SourceIndex(0) -13>Emitted(2, 57) Source(3, 31) + SourceIndex(0) -14>Emitted(2, 64) Source(3, 31) + SourceIndex(0) -15>Emitted(2, 65) Source(3, 32) + SourceIndex(0) -16>Emitted(2, 67) Source(3, 31) + SourceIndex(0) -17>Emitted(2, 68) Source(3, 32) + SourceIndex(0) -18>Emitted(2, 69) Source(3, 33) + SourceIndex(0) +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 5) Source(2, 5) + SourceIndex(0) +3 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +4 >Emitted(2, 11) Source(2, 11) + SourceIndex(0) +5 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +6 >Emitted(2, 15) Source(2, 15) + SourceIndex(0) +7 >Emitted(2, 29) Source(2, 21) + SourceIndex(0) +8 >Emitted(2, 36) Source(2, 21) + SourceIndex(0) +9 >Emitted(2, 37) Source(2, 22) + SourceIndex(0) +10>Emitted(2, 39) Source(2, 21) + SourceIndex(0) +11>Emitted(2, 40) Source(2, 22) + SourceIndex(0) +12>Emitted(2, 43) Source(2, 25) + SourceIndex(0) +13>Emitted(2, 57) Source(2, 31) + SourceIndex(0) +14>Emitted(2, 64) Source(2, 31) + SourceIndex(0) +15>Emitted(2, 65) Source(2, 32) + SourceIndex(0) +16>Emitted(2, 67) Source(2, 31) + SourceIndex(0) +17>Emitted(2, 68) Source(2, 32) + SourceIndex(0) +18>Emitted(2, 69) Source(2, 33) + SourceIndex(0) --- >>>//# sourceMappingURL=ternaryExpressionSourceMap.js.map \ No newline at end of file diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.symbols b/tests/baselines/reference/ternaryExpressionSourceMap.symbols index 5893e5cb2c5cf..39510b0b57cb1 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.symbols +++ b/tests/baselines/reference/ternaryExpressionSourceMap.symbols @@ -1,9 +1,8 @@ === tests/cases/compiler/ternaryExpressionSourceMap.ts === - var x = 1; ->x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 1, 3)) +>x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 0, 3)) var foo = x ? () => 0 : () => 0; ->foo : Symbol(foo, Decl(ternaryExpressionSourceMap.ts, 2, 3)) ->x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 1, 3)) +>foo : Symbol(foo, Decl(ternaryExpressionSourceMap.ts, 1, 3)) +>x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 0, 3)) diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.types b/tests/baselines/reference/ternaryExpressionSourceMap.types index d6d17091b4322..ccc36358491da 100644 --- a/tests/baselines/reference/ternaryExpressionSourceMap.types +++ b/tests/baselines/reference/ternaryExpressionSourceMap.types @@ -1,5 +1,4 @@ === tests/cases/compiler/ternaryExpressionSourceMap.ts === - var x = 1; >x : number >1 : 1 diff --git a/tests/baselines/reference/thisBinding2.errors.txt b/tests/baselines/reference/thisBinding2.errors.txt index ddfa078a2d270..c91a16c812a5b 100644 --- a/tests/baselines/reference/thisBinding2.errors.txt +++ b/tests/baselines/reference/thisBinding2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/compiler/thisBinding2.ts(11,11): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. +tests/cases/compiler/thisBinding2.ts(10,11): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. ==== tests/cases/compiler/thisBinding2.ts (1 errors) ==== - class C { x: number; constructor() { diff --git a/tests/baselines/reference/thisBinding2.js b/tests/baselines/reference/thisBinding2.js index 732cb4fac00e0..142cd9db4a5a2 100644 --- a/tests/baselines/reference/thisBinding2.js +++ b/tests/baselines/reference/thisBinding2.js @@ -1,5 +1,4 @@ //// [thisBinding2.ts] - class C { x: number; constructor() { diff --git a/tests/baselines/reference/thisInInvalidContexts.errors.txt b/tests/baselines/reference/thisInInvalidContexts.errors.txt index d33260fa108df..3581d6d6f29bc 100644 --- a/tests/baselines/reference/thisInInvalidContexts.errors.txt +++ b/tests/baselines/reference/thisInInvalidContexts.errors.txt @@ -3,12 +3,11 @@ tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(14,15): tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(22,15): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(28,13): error TS2331: 'this' cannot be referenced in a module or namespace body. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(36,13): error TS2526: A 'this' type is available only in a non-static member of a class or interface. -tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(38,25): error TS2507: Type 'any' is not a constructor function type. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(44,9): error TS2332: 'this' cannot be referenced in current location. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(45,9): error TS2332: 'this' cannot be referenced in current location. -==== tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts (8 errors) ==== +==== tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts (7 errors) ==== //'this' in static member initializer class ErrClass1 { static t = this; // Error @@ -57,8 +56,6 @@ tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(45,9): !!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. class ErrClass3 extends this { - ~~~~ -!!! error TS2507: Type 'any' is not a constructor function type. } diff --git a/tests/baselines/reference/thisInInvalidContextsExternalModule.errors.txt b/tests/baselines/reference/thisInInvalidContextsExternalModule.errors.txt index 8f84793a49fbb..f89b28978922a 100644 --- a/tests/baselines/reference/thisInInvalidContextsExternalModule.errors.txt +++ b/tests/baselines/reference/thisInInvalidContextsExternalModule.errors.txt @@ -3,12 +3,11 @@ tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalMod tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts(22,15): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts(28,13): error TS2331: 'this' cannot be referenced in a module or namespace body. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts(36,13): error TS2526: A 'this' type is available only in a non-static member of a class or interface. -tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts(38,25): error TS2507: Type 'any' is not a constructor function type. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts(44,9): error TS2332: 'this' cannot be referenced in current location. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts(45,9): error TS2332: 'this' cannot be referenced in current location. -==== tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts (8 errors) ==== +==== tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts (7 errors) ==== //'this' in static member initializer class ErrClass1 { static t = this; // Error @@ -57,8 +56,6 @@ tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalMod !!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. class ErrClass3 extends this { - ~~~~ -!!! error TS2507: Type 'any' is not a constructor function type. } diff --git a/tests/baselines/reference/thisInObjectLiterals.errors.txt b/tests/baselines/reference/thisInObjectLiterals.errors.txt index 52ff6789559f0..50c10465ee820 100644 --- a/tests/baselines/reference/thisInObjectLiterals.errors.txt +++ b/tests/baselines/reference/thisInObjectLiterals.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/expressions/thisKeyword/thisInObjectLiterals.ts(15,5): error TS7023: 'f' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -tests/cases/conformance/expressions/thisKeyword/thisInObjectLiterals.ts(16,21): error TS2339: Property 'spaaace' does not exist on type '{ f(): any; }'. +tests/cases/conformance/expressions/thisKeyword/thisInObjectLiterals.ts(14,5): error TS7023: 'f' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +tests/cases/conformance/expressions/thisKeyword/thisInObjectLiterals.ts(15,21): error TS2339: Property 'spaaace' does not exist on type '{ f(): any; }'. ==== tests/cases/conformance/expressions/thisKeyword/thisInObjectLiterals.ts (2 errors) ==== - class MyClass { t: number; diff --git a/tests/baselines/reference/thisInObjectLiterals.js b/tests/baselines/reference/thisInObjectLiterals.js index 33a55cd5c71db..6331f12105d91 100644 --- a/tests/baselines/reference/thisInObjectLiterals.js +++ b/tests/baselines/reference/thisInObjectLiterals.js @@ -1,5 +1,4 @@ //// [thisInObjectLiterals.ts] - class MyClass { t: number; diff --git a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.js b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.js index 51cc5a24bb649..f492460cff080 100644 --- a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.js +++ b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.js @@ -1,5 +1,4 @@ //// [thisTypeInBasePropertyAndDerivedContainerOfBase01.ts] - interface BoxOfFoo { item: T } diff --git a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.symbols b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.symbols index 566bf3aa0935e..a7f98468e2ef7 100644 --- a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.symbols +++ b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.symbols @@ -1,27 +1,26 @@ === tests/cases/conformance/types/thisType/thisTypeInBasePropertyAndDerivedContainerOfBase01.ts === - interface BoxOfFoo { >BoxOfFoo : Symbol(BoxOfFoo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 0)) ->T : Symbol(T, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 1, 19)) ->Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 3, 1)) +>T : Symbol(T, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 19)) +>Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 2, 1)) item: T ->item : Symbol(BoxOfFoo.item, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 1, 35)) ->T : Symbol(T, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 1, 19)) +>item : Symbol(BoxOfFoo.item, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 35)) +>T : Symbol(T, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 19)) } interface Foo { ->Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 3, 1)) +>Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 2, 1)) self: this; ->self : Symbol(Foo.self, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 5, 15)) +>self : Symbol(Foo.self, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 4, 15)) } interface Bar extends Foo { ->Bar : Symbol(Bar, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 7, 1)) ->Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 3, 1)) +>Bar : Symbol(Bar, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 6, 1)) +>Foo : Symbol(Foo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 2, 1)) other: BoxOfFoo; ->other : Symbol(Bar.other, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 9, 27)) +>other : Symbol(Bar.other, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 8, 27)) >BoxOfFoo : Symbol(BoxOfFoo, Decl(thisTypeInBasePropertyAndDerivedContainerOfBase01.ts, 0, 0)) } diff --git a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.types b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.types index 9f6b83df05748..d5142a1dfe329 100644 --- a/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.types +++ b/tests/baselines/reference/thisTypeInBasePropertyAndDerivedContainerOfBase01.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/thisType/thisTypeInBasePropertyAndDerivedContainerOfBase01.ts === - interface BoxOfFoo { >BoxOfFoo : BoxOfFoo >T : T diff --git a/tests/baselines/reference/thisTypeInFunctions2.errors.txt b/tests/baselines/reference/thisTypeInFunctions2.errors.txt index 86721a769711e..f18f4707aa669 100644 --- a/tests/baselines/reference/thisTypeInFunctions2.errors.txt +++ b/tests/baselines/reference/thisTypeInFunctions2.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/types/thisType/thisTypeInFunctions2.ts(15,5): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. +tests/cases/conformance/types/thisType/thisTypeInFunctions2.ts(14,5): error TS7010: 'foo', which lacks return-type annotation, implicitly has an 'any' return type. ==== tests/cases/conformance/types/thisType/thisTypeInFunctions2.ts (1 errors) ==== - interface IndexedWithThis { // this is a workaround for React init?: (this: this) => void; diff --git a/tests/baselines/reference/thisTypeInFunctions2.js b/tests/baselines/reference/thisTypeInFunctions2.js index 7608629ea89e6..978f79483b03a 100644 --- a/tests/baselines/reference/thisTypeInFunctions2.js +++ b/tests/baselines/reference/thisTypeInFunctions2.js @@ -1,5 +1,4 @@ //// [thisTypeInFunctions2.ts] - interface IndexedWithThis { // this is a workaround for React init?: (this: this) => void; diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.js b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.js index d9020c79e29b4..fc4e6d7825320 100644 --- a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.js +++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.js @@ -1,5 +1,4 @@ //// [thisTypeInNativeThisAssignableMethods.ts] - class A { options: string[]; diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols index 2ff555baa5414..bf1e8c8d1b529 100644 --- a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols +++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols @@ -1,38 +1,37 @@ === tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts === - class A { >A : Symbol(A, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 0)) options: string[]; ->options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9)) addOptions(options: string[]) { ->addOptions : Symbol(A.addOptions, Decl(thisTypeInNativeThisAssignableMethods.ts, 2, 22)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 4, 15)) +>addOptions : Symbol(A.addOptions, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 22)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 3, 15)) if (!this.options) { ->this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9)) >this : Symbol(A, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 0)) ->options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9)) this.options = []; ->this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9)) >this : Symbol(A, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 0)) ->options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9)) } options.forEach(function (item) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 4, 15)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 3, 15)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 8, 34)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 7, 34)) this.options.push(item); >this.options.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 1, 9)) +>options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 8, 34)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 7, 34)) }, this); >this : Symbol(A, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 0)) @@ -42,33 +41,33 @@ class A { } testUndefined(options: string[]) { ->testUndefined : Symbol(A.testUndefined, Decl(thisTypeInNativeThisAssignableMethods.ts, 12, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 18)) +>testUndefined : Symbol(A.testUndefined, Decl(thisTypeInNativeThisAssignableMethods.ts, 11, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 13, 18)) const undefinedArr: Array = [] ->undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 15, 13)) +>undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 13)) >Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) options.forEach(function () { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 18)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 13, 18)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) undefinedArr.push(this); >undefinedArr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 15, 13)) +>undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 13)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) }); // case1 options.forEach(function () { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 18)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 13, 18)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) undefinedArr.push(this); >undefinedArr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 15, 13)) +>undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 13)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) @@ -77,27 +76,27 @@ class A { options.forEach(function () { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 18)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 13, 18)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) undefinedArr.push(this); >undefinedArr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 15, 13)) +>undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 13)) >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) }, null); // case3 const arrLike = {} as ArrayLike ->arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 26, 13)) +>arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 25, 13)) >ArrayLike : Symbol(ArrayLike, Decl(lib.es5.d.ts, --, --)) Array.from(arrLike, function (item) { >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 26, 13)) ->item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 27, 38)) +>arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 25, 13)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 26, 38)) return this === undefined ? 2 : 1; >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) @@ -107,15 +106,15 @@ class A { >undefined : Symbol(undefined) const iterLike = [] as Iterable ->iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 31, 13)) +>iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 30, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) Array.from(iterLike, function (item) { >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 31, 13)) ->item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 32, 39)) +>iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 30, 13)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 31, 39)) return this === undefined ? 2 : 1; >this : Symbol(this, Decl(lib.es2015.iterable.d.ts, --, --)) @@ -126,1444 +125,1444 @@ class A { } test(options: string[]) { ->test : Symbol(A.test, Decl(thisTypeInNativeThisAssignableMethods.ts, 35, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>test : Symbol(A.test, Decl(thisTypeInNativeThisAssignableMethods.ts, 34, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) options: [] as string[] ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 42, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 42, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 41, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 41, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 42, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 41, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 42, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 41, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 46, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 46, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 45, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 45, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 46, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 45, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 46, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 45, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 50, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 50, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 49, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 49, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 50, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 49, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 50, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 49, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 54, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 59, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 59, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 58, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 58, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 59, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 58, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 59, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 58, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 63, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 63, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 62, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 62, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 63, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 62, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 63, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 62, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 9)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 67, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 67, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 66, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 66, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 67, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 66, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 67, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 66, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) const arrLike = {} as ArrayLike ->arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 71, 13)) +>arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 70, 13)) >ArrayLike : Symbol(ArrayLike, Decl(lib.es5.d.ts, --, --)) Array.from(arrLike, function (item) { >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 71, 13)) ->item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 72, 38)) +>arrLike : Symbol(arrLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 70, 13)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 71, 38)) return this.options[item].length >this.options[item].length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 72, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 71, 38)) >length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) }, thisObject) ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) const iterLike = [] as Iterable ->iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 76, 13)) +>iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 75, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) Array.from(iterLike, function (item) { >Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 76, 13)) ->item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 77, 39)) +>iterLike : Symbol(iterLike, Decl(thisTypeInNativeThisAssignableMethods.ts, 75, 13)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 76, 39)) return this.options[item].length >this.options[item].length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) >this : Symbol(this, Decl(lib.es2015.iterable.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 28)) ->item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 77, 39)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28)) +>item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 76, 39)) >length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) }, thisObject) ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 38, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13)) } test1(options: string[]) { ->test1 : Symbol(A.test1, Decl(thisTypeInNativeThisAssignableMethods.ts, 80, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>test1 : Symbol(A.test1, Decl(thisTypeInNativeThisAssignableMethods.ts, 79, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13)) options: [] as ReadonlyArray ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) >ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 87, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 87, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 86, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 86, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 87, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 86, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 87, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 86, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 91, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 91, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 90, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 90, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 91, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 90, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 91, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 90, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 95, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 95, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 94, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 94, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 95, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 94, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 95, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 94, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 99, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 104, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 104, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 103, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 103, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 104, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 103, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 104, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 103, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 108, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 108, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 107, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 107, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 108, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 107, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 108, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 107, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 112, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 112, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 111, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 111, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 112, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 111, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 112, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 111, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 83, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13)) } test2(options: Int8Array[]) { ->test2 : Symbol(A.test2, Decl(thisTypeInNativeThisAssignableMethods.ts, 115, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>test2 : Symbol(A.test2, Decl(thisTypeInNativeThisAssignableMethods.ts, 114, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10)) >Int8Array : Symbol(Int8Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13)) options: [] as Int8Array[] ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) >Int8Array : Symbol(Int8Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 122, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 122, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 121, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 121, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 122, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 121, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 122, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 121, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 126, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 126, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 125, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 125, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 126, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 125, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 126, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 125, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 130, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 130, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 129, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 129, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 130, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 129, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 130, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 129, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 134, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 139, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 139, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 138, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 138, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 139, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 138, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 139, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 138, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 143, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 143, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 142, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 142, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 143, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 142, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 143, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 142, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 147, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 147, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 146, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 146, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 147, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 146, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 147, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 146, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 118, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13)) } test3(options: Uint8Array[]) { ->test3 : Symbol(A.test3, Decl(thisTypeInNativeThisAssignableMethods.ts, 150, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>test3 : Symbol(A.test3, Decl(thisTypeInNativeThisAssignableMethods.ts, 149, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10)) >Uint8Array : Symbol(Uint8Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13)) options: [] as Uint8Array[] ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) >Uint8Array : Symbol(Uint8Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 157, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 157, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 156, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 156, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 157, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 156, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 157, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 156, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 161, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 161, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 160, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 160, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 161, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 160, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 161, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 160, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 165, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 165, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 164, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 164, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 165, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 164, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 165, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 164, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 169, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 174, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 174, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 173, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 173, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 174, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 173, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 174, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 173, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 178, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 178, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 177, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 177, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 178, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 177, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 178, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 177, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 182, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 182, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 181, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 181, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 182, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 181, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 182, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 181, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 153, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13)) } test4(options: Float32Array[]) { ->test4 : Symbol(A.test4, Decl(thisTypeInNativeThisAssignableMethods.ts, 185, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>test4 : Symbol(A.test4, Decl(thisTypeInNativeThisAssignableMethods.ts, 184, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10)) >Float32Array : Symbol(Float32Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13)) options: [] as Float32Array[] ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) >Float32Array : Symbol(Float32Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 192, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 192, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 191, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 191, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 192, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 191, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 192, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 191, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 196, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 196, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 195, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 195, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 196, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 195, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 196, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 195, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 200, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 200, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 199, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 199, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 200, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 199, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 200, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 199, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 204, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 209, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 209, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 208, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 208, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 209, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 208, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 209, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 208, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 213, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 213, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 212, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 212, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 213, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 212, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 213, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 212, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 217, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 217, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 216, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 216, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 217, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 216, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 217, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 216, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 188, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13)) } test5(options: Uint8ClampedArray[]) { ->test5 : Symbol(A.test5, Decl(thisTypeInNativeThisAssignableMethods.ts, 220, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>test5 : Symbol(A.test5, Decl(thisTypeInNativeThisAssignableMethods.ts, 219, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10)) >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13)) options: [] as Uint8ClampedArray[] ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 227, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 227, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 226, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 226, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 227, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 226, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 227, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 226, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 231, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 231, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 230, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 230, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 231, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 230, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 231, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 230, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 235, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 235, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 234, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 234, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 235, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 234, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 235, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 234, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 239, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 244, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 244, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 243, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 243, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 244, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 243, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 244, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 243, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 248, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 248, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 247, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 247, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 248, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 247, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 248, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 247, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 252, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 252, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 251, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 251, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 252, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 251, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 252, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 251, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 223, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13)) } test6(options: Int16Array[]) { ->test6 : Symbol(A.test6, Decl(thisTypeInNativeThisAssignableMethods.ts, 255, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>test6 : Symbol(A.test6, Decl(thisTypeInNativeThisAssignableMethods.ts, 254, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10)) >Int16Array : Symbol(Int16Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13)) options: [] as Int16Array[] ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) >Int16Array : Symbol(Int16Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 262, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 262, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 261, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 261, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 262, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 261, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 262, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 261, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 266, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 266, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 265, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 265, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 266, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 265, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 266, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 265, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 270, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 270, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 269, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 269, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 270, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 269, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 270, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 269, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 274, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 279, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 279, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 278, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 278, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 279, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 278, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 279, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 278, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 283, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 283, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 282, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 282, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 283, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 282, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 283, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 282, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 287, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 287, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 286, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 286, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 287, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 286, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 287, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 286, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 258, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13)) } test7(options: Uint16Array[]) { ->test7 : Symbol(A.test7, Decl(thisTypeInNativeThisAssignableMethods.ts, 290, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>test7 : Symbol(A.test7, Decl(thisTypeInNativeThisAssignableMethods.ts, 289, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10)) >Uint16Array : Symbol(Uint16Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13)) options: [] as Uint16Array[] ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) >Uint16Array : Symbol(Uint16Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 297, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 297, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 296, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 296, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 297, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 296, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 297, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 296, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 301, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 301, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 300, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 300, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 301, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 300, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 301, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 300, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 305, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 305, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 304, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 304, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 305, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 304, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 305, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 304, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 309, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 314, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 314, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 313, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 313, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 314, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 313, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 314, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 313, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 318, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 318, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 317, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 317, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 318, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 317, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 318, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 317, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 322, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 322, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 321, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 321, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 322, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 321, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 322, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 321, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 293, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13)) } test8(options: Uint32Array[]) { ->test8 : Symbol(A.test8, Decl(thisTypeInNativeThisAssignableMethods.ts, 325, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>test8 : Symbol(A.test8, Decl(thisTypeInNativeThisAssignableMethods.ts, 324, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10)) >Uint32Array : Symbol(Uint32Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13)) options: [] as Uint32Array[] ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) >Uint32Array : Symbol(Uint32Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 332, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 332, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 331, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 331, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 332, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 331, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 332, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 331, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 336, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 336, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 335, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 335, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 336, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 335, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 336, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 335, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 340, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 340, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 339, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 339, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 340, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 339, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 340, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 339, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 344, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 349, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 349, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 348, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 348, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 349, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 348, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 349, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 348, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 353, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 353, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 352, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 352, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 353, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 352, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 353, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 352, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 357, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 357, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 356, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 356, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 357, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 356, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 357, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 356, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 328, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13)) } test9(options: Float64Array[]) { ->test9 : Symbol(A.test9, Decl(thisTypeInNativeThisAssignableMethods.ts, 360, 5)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>test9 : Symbol(A.test9, Decl(thisTypeInNativeThisAssignableMethods.ts, 359, 5)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10)) >Float64Array : Symbol(Float64Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) const thisObject = { ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13)) options: [] as Float64Array[] ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) >Float64Array : Symbol(Float64Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) }; options.find(function (val, index) { >options.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10)) >find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 367, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 367, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 366, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 366, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 367, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 366, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 367, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 366, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13)) options.findIndex(function (val, index) { >options.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10)) >findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 371, 36)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 371, 40)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 370, 36)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 370, 40)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 371, 36)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 370, 36)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) >this : Symbol(this, Decl(lib.es2015.core.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 371, 40)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 370, 40)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13)) options.forEach(function (val, index) { >options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 375, 34)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 375, 38)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 374, 34)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 374, 38)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 375, 34)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 374, 34)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 375, 38)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 374, 38)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13)) options.map(function (val, index) { >options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10)) >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 30)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 34)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 30)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 34)) if (val === this.options[index]) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 30)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 30)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 34)) return this.options[index]; ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 379, 34)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 34)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13)) options.some(function (val, index) { >options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10)) >some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 384, 31)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 384, 35)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 383, 31)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 383, 35)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 384, 31)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 383, 31)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 384, 35)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 383, 35)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13)) options.filter(function (val, index) { >options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10)) >filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 388, 33)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 388, 37)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 387, 33)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 387, 37)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 388, 33)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 387, 33)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 388, 37)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 387, 37)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13)) options.every(function (val, index) { >options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 10)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10)) >every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 392, 32)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 392, 36)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 391, 32)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 391, 36)) return val === this.options[index]; ->val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 392, 32)) ->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) +>val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 391, 32)) +>this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) >this : Symbol(this, Decl(lib.es5.d.ts, --, --)) ->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 28)) ->index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 392, 36)) +>options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28)) +>index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 391, 36)) }, thisObject); ->thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 363, 13)) +>thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13)) } } diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types index e64918181ca69..d2ec6344af0bb 100644 --- a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types +++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types @@ -1,5 +1,4 @@ === tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts === - class A { >A : A diff --git a/tests/baselines/reference/thisTypeInObjectLiterals.js b/tests/baselines/reference/thisTypeInObjectLiterals.js index 18f0a6407bcfb..342c9d58c8490 100644 --- a/tests/baselines/reference/thisTypeInObjectLiterals.js +++ b/tests/baselines/reference/thisTypeInObjectLiterals.js @@ -1,5 +1,4 @@ //// [thisTypeInObjectLiterals.ts] - let o = { d: "bar", m() { diff --git a/tests/baselines/reference/thisTypeInObjectLiterals.symbols b/tests/baselines/reference/thisTypeInObjectLiterals.symbols index 374c790bd8fff..fd6d6ecebd5c8 100644 --- a/tests/baselines/reference/thisTypeInObjectLiterals.symbols +++ b/tests/baselines/reference/thisTypeInObjectLiterals.symbols @@ -1,105 +1,104 @@ === tests/cases/conformance/types/thisType/thisTypeInObjectLiterals.ts === - let o = { ->o : Symbol(o, Decl(thisTypeInObjectLiterals.ts, 1, 3)) +>o : Symbol(o, Decl(thisTypeInObjectLiterals.ts, 0, 3)) d: "bar", ->d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 1, 9)) +>d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 0, 9)) m() { ->m : Symbol(m, Decl(thisTypeInObjectLiterals.ts, 2, 13)) +>m : Symbol(m, Decl(thisTypeInObjectLiterals.ts, 1, 13)) return this.d.length; >this.d.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->this.d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 1, 9)) ->this : Symbol(o, Decl(thisTypeInObjectLiterals.ts, 1, 7)) ->d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 1, 9)) +>this.d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 0, 9)) +>this : Symbol(o, Decl(thisTypeInObjectLiterals.ts, 0, 7)) +>d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 0, 9)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) }, f: function() { ->f : Symbol(f, Decl(thisTypeInObjectLiterals.ts, 5, 6)) +>f : Symbol(f, Decl(thisTypeInObjectLiterals.ts, 4, 6)) return this.d.length; >this.d.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->this.d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 1, 9)) ->this : Symbol(o, Decl(thisTypeInObjectLiterals.ts, 1, 7)) ->d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 1, 9)) +>this.d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 0, 9)) +>this : Symbol(o, Decl(thisTypeInObjectLiterals.ts, 0, 7)) +>d : Symbol(d, Decl(thisTypeInObjectLiterals.ts, 0, 9)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) } } let mutuallyRecursive = { ->mutuallyRecursive : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 11, 3)) +>mutuallyRecursive : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 10, 3)) a: 100, ->a : Symbol(a, Decl(thisTypeInObjectLiterals.ts, 11, 25)) +>a : Symbol(a, Decl(thisTypeInObjectLiterals.ts, 10, 25)) start() { ->start : Symbol(start, Decl(thisTypeInObjectLiterals.ts, 12, 11)) +>start : Symbol(start, Decl(thisTypeInObjectLiterals.ts, 11, 11)) return this.passthrough(this.a); ->this.passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 15, 6)) ->this : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 11, 23)) ->passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 15, 6)) ->this.a : Symbol(a, Decl(thisTypeInObjectLiterals.ts, 11, 25)) ->this : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 11, 23)) ->a : Symbol(a, Decl(thisTypeInObjectLiterals.ts, 11, 25)) +>this.passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 14, 6)) +>this : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 10, 23)) +>passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 14, 6)) +>this.a : Symbol(a, Decl(thisTypeInObjectLiterals.ts, 10, 25)) +>this : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 10, 23)) +>a : Symbol(a, Decl(thisTypeInObjectLiterals.ts, 10, 25)) }, passthrough(n: number) { ->passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 15, 6)) ->n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 16, 16)) +>passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 14, 6)) +>n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 15, 16)) return this.sub1(n); ->this.sub1 : Symbol(sub1, Decl(thisTypeInObjectLiterals.ts, 18, 6)) ->this : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 11, 23)) ->sub1 : Symbol(sub1, Decl(thisTypeInObjectLiterals.ts, 18, 6)) ->n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 16, 16)) +>this.sub1 : Symbol(sub1, Decl(thisTypeInObjectLiterals.ts, 17, 6)) +>this : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 10, 23)) +>sub1 : Symbol(sub1, Decl(thisTypeInObjectLiterals.ts, 17, 6)) +>n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 15, 16)) }, sub1(n: number): number { ->sub1 : Symbol(sub1, Decl(thisTypeInObjectLiterals.ts, 18, 6)) ->n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 19, 9)) +>sub1 : Symbol(sub1, Decl(thisTypeInObjectLiterals.ts, 17, 6)) +>n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 18, 9)) if (n > 0) { ->n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 19, 9)) +>n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 18, 9)) return this.passthrough(n - 1); ->this.passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 15, 6)) ->this : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 11, 23)) ->passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 15, 6)) ->n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 19, 9)) +>this.passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 14, 6)) +>this : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 10, 23)) +>passthrough : Symbol(passthrough, Decl(thisTypeInObjectLiterals.ts, 14, 6)) +>n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 18, 9)) } return n; ->n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 19, 9)) +>n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 18, 9)) } } var i: number = mutuallyRecursive.start(); ->i : Symbol(i, Decl(thisTypeInObjectLiterals.ts, 26, 3)) ->mutuallyRecursive.start : Symbol(start, Decl(thisTypeInObjectLiterals.ts, 12, 11)) ->mutuallyRecursive : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 11, 3)) ->start : Symbol(start, Decl(thisTypeInObjectLiterals.ts, 12, 11)) +>i : Symbol(i, Decl(thisTypeInObjectLiterals.ts, 25, 3)) +>mutuallyRecursive.start : Symbol(start, Decl(thisTypeInObjectLiterals.ts, 11, 11)) +>mutuallyRecursive : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 10, 3)) +>start : Symbol(start, Decl(thisTypeInObjectLiterals.ts, 11, 11)) interface I { ->I : Symbol(I, Decl(thisTypeInObjectLiterals.ts, 26, 42)) +>I : Symbol(I, Decl(thisTypeInObjectLiterals.ts, 25, 42)) a: number; ->a : Symbol(I.a, Decl(thisTypeInObjectLiterals.ts, 27, 13)) +>a : Symbol(I.a, Decl(thisTypeInObjectLiterals.ts, 26, 13)) start(): number; ->start : Symbol(I.start, Decl(thisTypeInObjectLiterals.ts, 28, 14)) +>start : Symbol(I.start, Decl(thisTypeInObjectLiterals.ts, 27, 14)) passthrough(n: number): number; ->passthrough : Symbol(I.passthrough, Decl(thisTypeInObjectLiterals.ts, 29, 20)) ->n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 30, 16)) +>passthrough : Symbol(I.passthrough, Decl(thisTypeInObjectLiterals.ts, 28, 20)) +>n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 29, 16)) sub1(n: number): number; ->sub1 : Symbol(I.sub1, Decl(thisTypeInObjectLiterals.ts, 30, 35)) ->n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 31, 9)) +>sub1 : Symbol(I.sub1, Decl(thisTypeInObjectLiterals.ts, 29, 35)) +>n : Symbol(n, Decl(thisTypeInObjectLiterals.ts, 30, 9)) } var impl: I = mutuallyRecursive; ->impl : Symbol(impl, Decl(thisTypeInObjectLiterals.ts, 33, 3)) ->I : Symbol(I, Decl(thisTypeInObjectLiterals.ts, 26, 42)) ->mutuallyRecursive : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 11, 3)) +>impl : Symbol(impl, Decl(thisTypeInObjectLiterals.ts, 32, 3)) +>I : Symbol(I, Decl(thisTypeInObjectLiterals.ts, 25, 42)) +>mutuallyRecursive : Symbol(mutuallyRecursive, Decl(thisTypeInObjectLiterals.ts, 10, 3)) diff --git a/tests/baselines/reference/thisTypeInObjectLiterals.types b/tests/baselines/reference/thisTypeInObjectLiterals.types index d4e6188b9cfc8..d5c6d851faf15 100644 --- a/tests/baselines/reference/thisTypeInObjectLiterals.types +++ b/tests/baselines/reference/thisTypeInObjectLiterals.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/thisType/thisTypeInObjectLiterals.ts === - let o = { >o : { d: string; m(): number; f: () => number; } >{ d: "bar", m() { return this.d.length; }, f: function() { return this.d.length; }} : { d: string; m(): number; f: () => number; } diff --git a/tests/baselines/reference/thisTypeInObjectLiterals2.js b/tests/baselines/reference/thisTypeInObjectLiterals2.js index a9b666fda8fbe..ca62ee376655e 100644 --- a/tests/baselines/reference/thisTypeInObjectLiterals2.js +++ b/tests/baselines/reference/thisTypeInObjectLiterals2.js @@ -1,5 +1,4 @@ //// [thisTypeInObjectLiterals2.ts] - // In methods of an object literal with no contextual type, 'this' has the type // of the object literal. @@ -244,9 +243,9 @@ vue.hello; //// [thisTypeInObjectLiterals2.js] +"use strict"; // In methods of an object literal with no contextual type, 'this' has the type // of the object literal. -"use strict"; var obj1 = { a: 1, f: function () { diff --git a/tests/baselines/reference/thisTypeInObjectLiterals2.symbols b/tests/baselines/reference/thisTypeInObjectLiterals2.symbols index 4c3e60c7536f1..956fea7a85c0e 100644 --- a/tests/baselines/reference/thisTypeInObjectLiterals2.symbols +++ b/tests/baselines/reference/thisTypeInObjectLiterals2.symbols @@ -1,65 +1,64 @@ === tests/cases/conformance/types/thisType/thisTypeInObjectLiterals2.ts === - // In methods of an object literal with no contextual type, 'this' has the type // of the object literal. let obj1 = { ->obj1 : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 4, 3)) +>obj1 : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 3, 3)) a: 1, ->a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 4, 12)) +>a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 3, 12)) f() { ->f : Symbol(f, Decl(thisTypeInObjectLiterals2.ts, 5, 9)) +>f : Symbol(f, Decl(thisTypeInObjectLiterals2.ts, 4, 9)) return this.a; ->this.a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 4, 12)) ->this : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 4, 10)) ->a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 4, 12)) +>this.a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 3, 12)) +>this : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 3, 10)) +>a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 3, 12)) }, b: "hello", ->b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 8, 6)) +>b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 7, 6)) c: { ->c : Symbol(c, Decl(thisTypeInObjectLiterals2.ts, 9, 15)) +>c : Symbol(c, Decl(thisTypeInObjectLiterals2.ts, 8, 15)) g() { ->g : Symbol(g, Decl(thisTypeInObjectLiterals2.ts, 10, 8)) +>g : Symbol(g, Decl(thisTypeInObjectLiterals2.ts, 9, 8)) this.g(); ->this.g : Symbol(g, Decl(thisTypeInObjectLiterals2.ts, 10, 8)) ->this : Symbol(__object, Decl(thisTypeInObjectLiterals2.ts, 10, 6)) ->g : Symbol(g, Decl(thisTypeInObjectLiterals2.ts, 10, 8)) +>this.g : Symbol(g, Decl(thisTypeInObjectLiterals2.ts, 9, 8)) +>this : Symbol(__object, Decl(thisTypeInObjectLiterals2.ts, 9, 6)) +>g : Symbol(g, Decl(thisTypeInObjectLiterals2.ts, 9, 8)) } }, get d() { ->d : Symbol(d, Decl(thisTypeInObjectLiterals2.ts, 14, 6)) +>d : Symbol(d, Decl(thisTypeInObjectLiterals2.ts, 13, 6)) return this.a; ->this.a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 4, 12)) ->this : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 4, 10)) ->a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 4, 12)) +>this.a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 3, 12)) +>this : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 3, 10)) +>a : Symbol(a, Decl(thisTypeInObjectLiterals2.ts, 3, 12)) }, get e() { ->e : Symbol(e, Decl(thisTypeInObjectLiterals2.ts, 17, 6), Decl(thisTypeInObjectLiterals2.ts, 20, 6)) +>e : Symbol(e, Decl(thisTypeInObjectLiterals2.ts, 16, 6), Decl(thisTypeInObjectLiterals2.ts, 19, 6)) return this.b; ->this.b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 8, 6)) ->this : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 4, 10)) ->b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 8, 6)) +>this.b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 7, 6)) +>this : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 3, 10)) +>b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 7, 6)) }, set e(value) { ->e : Symbol(e, Decl(thisTypeInObjectLiterals2.ts, 17, 6), Decl(thisTypeInObjectLiterals2.ts, 20, 6)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 21, 10)) +>e : Symbol(e, Decl(thisTypeInObjectLiterals2.ts, 16, 6), Decl(thisTypeInObjectLiterals2.ts, 19, 6)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 20, 10)) this.b = value; ->this.b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 8, 6)) ->this : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 4, 10)) ->b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 8, 6)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 21, 10)) +>this.b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 7, 6)) +>this : Symbol(obj1, Decl(thisTypeInObjectLiterals2.ts, 3, 10)) +>b : Symbol(b, Decl(thisTypeInObjectLiterals2.ts, 7, 6)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 20, 10)) } }; @@ -67,286 +66,286 @@ let obj1 = { // contextual type. type Point = { ->Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 24, 2)) +>Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 23, 2)) x: number; ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) y: number; ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) z?: number; ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) moveBy(dx: number, dy: number, dz?: number): void; ->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 32, 15)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 33, 11)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 33, 22)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 33, 34)) +>moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 31, 15)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 32, 11)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 32, 22)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 32, 34)) } let p1: Point = { ->p1 : Symbol(p1, Decl(thisTypeInObjectLiterals2.ts, 36, 3)) ->Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 24, 2)) +>p1 : Symbol(p1, Decl(thisTypeInObjectLiterals2.ts, 35, 3)) +>Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 23, 2)) x: 10, ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 36, 17)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 35, 17)) y: 20, ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 37, 10)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 36, 10)) moveBy(dx, dy, dz) { ->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 38, 10)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 39, 11)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 39, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 39, 18)) +>moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 37, 10)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 38, 11)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 38, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 38, 18)) this.x += dx; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 39, 11)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 38, 11)) this.y += dy; ->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 39, 14)) +>this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 38, 14)) if (this.z && dz) { ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 39, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 38, 18)) this.z += dz; ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 39, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 38, 18)) } } }; let p2: Point | null = { ->p2 : Symbol(p2, Decl(thisTypeInObjectLiterals2.ts, 48, 3)) ->Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 24, 2)) +>p2 : Symbol(p2, Decl(thisTypeInObjectLiterals2.ts, 47, 3)) +>Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 23, 2)) x: 10, ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 48, 24)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 47, 24)) y: 20, ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 49, 10)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 48, 10)) moveBy(dx, dy, dz) { ->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 50, 10)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 51, 11)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 51, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 51, 18)) +>moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 49, 10)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 50, 11)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 50, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 50, 18)) this.x += dx; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 51, 11)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 50, 11)) this.y += dy; ->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 51, 14)) +>this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 50, 14)) if (this.z && dz) { ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 51, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 50, 18)) this.z += dz; ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 51, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 50, 18)) } } }; let p3: Point | undefined = { ->p3 : Symbol(p3, Decl(thisTypeInObjectLiterals2.ts, 60, 3)) ->Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 24, 2)) +>p3 : Symbol(p3, Decl(thisTypeInObjectLiterals2.ts, 59, 3)) +>Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 23, 2)) x: 10, ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 60, 29)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 59, 29)) y: 20, ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 61, 10)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 60, 10)) moveBy(dx, dy, dz) { ->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 62, 10)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 63, 11)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 63, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 63, 18)) +>moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 61, 10)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 62, 11)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 62, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 62, 18)) this.x += dx; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 63, 11)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 62, 11)) this.y += dy; ->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 63, 14)) +>this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 62, 14)) if (this.z && dz) { ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 63, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 62, 18)) this.z += dz; ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 63, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 62, 18)) } } }; let p4: Point | null | undefined = { ->p4 : Symbol(p4, Decl(thisTypeInObjectLiterals2.ts, 72, 3)) ->Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 24, 2)) +>p4 : Symbol(p4, Decl(thisTypeInObjectLiterals2.ts, 71, 3)) +>Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 23, 2)) x: 10, ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 72, 36)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 71, 36)) y: 20, ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 73, 10)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 72, 10)) moveBy(dx, dy, dz) { ->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 74, 10)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 75, 11)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 75, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 75, 18)) +>moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 73, 10)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 74, 11)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 74, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 74, 18)) this.x += dx; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 75, 11)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 74, 11)) this.y += dy; ->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 75, 14)) +>this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 74, 14)) if (this.z && dz) { ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 75, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 74, 18)) this.z += dz; ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 75, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 74, 18)) } } }; declare function f1(p: Point): void; ->f1 : Symbol(f1, Decl(thisTypeInObjectLiterals2.ts, 82, 2)) ->p : Symbol(p, Decl(thisTypeInObjectLiterals2.ts, 84, 20)) ->Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 24, 2)) +>f1 : Symbol(f1, Decl(thisTypeInObjectLiterals2.ts, 81, 2)) +>p : Symbol(p, Decl(thisTypeInObjectLiterals2.ts, 83, 20)) +>Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 23, 2)) f1({ ->f1 : Symbol(f1, Decl(thisTypeInObjectLiterals2.ts, 82, 2)) +>f1 : Symbol(f1, Decl(thisTypeInObjectLiterals2.ts, 81, 2)) x: 10, ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 86, 4)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 85, 4)) y: 20, ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 87, 10)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 86, 10)) moveBy(dx, dy, dz) { ->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 88, 10)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 89, 11)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 89, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 89, 18)) +>moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 87, 10)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 88, 11)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 88, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 88, 18)) this.x += dx; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 89, 11)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 88, 11)) this.y += dy; ->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 89, 14)) +>this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 88, 14)) if (this.z && dz) { ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 89, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 88, 18)) this.z += dz; ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 89, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 88, 18)) } } }); declare function f2(p: Point | null | undefined): void; ->f2 : Symbol(f2, Decl(thisTypeInObjectLiterals2.ts, 96, 3)) ->p : Symbol(p, Decl(thisTypeInObjectLiterals2.ts, 98, 20)) ->Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 24, 2)) +>f2 : Symbol(f2, Decl(thisTypeInObjectLiterals2.ts, 95, 3)) +>p : Symbol(p, Decl(thisTypeInObjectLiterals2.ts, 97, 20)) +>Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 23, 2)) f2({ ->f2 : Symbol(f2, Decl(thisTypeInObjectLiterals2.ts, 96, 3)) +>f2 : Symbol(f2, Decl(thisTypeInObjectLiterals2.ts, 95, 3)) x: 10, ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 100, 4)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 99, 4)) y: 20, ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 101, 10)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 100, 10)) moveBy(dx, dy, dz) { ->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 102, 10)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 103, 11)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 103, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 103, 18)) +>moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 101, 10)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 102, 11)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 102, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 102, 18)) this.x += dx; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 103, 11)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 102, 11)) this.y += dy; ->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 103, 14)) +>this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 102, 14)) if (this.z && dz) { ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 103, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 102, 18)) this.z += dz; ->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 31, 14)) ->dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 103, 18)) +>this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14)) +>dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 102, 18)) } } }); @@ -355,59 +354,59 @@ f2({ // ThisType, 'this' is of type T. type ObjectDescriptor = { ->ObjectDescriptor : Symbol(ObjectDescriptor, Decl(thisTypeInObjectLiterals2.ts, 110, 3)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 115, 22)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 115, 24)) +>ObjectDescriptor : Symbol(ObjectDescriptor, Decl(thisTypeInObjectLiterals2.ts, 109, 3)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 114, 22)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 114, 24)) data?: D; ->data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 115, 31)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 115, 22)) +>data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 114, 31)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 114, 22)) methods?: M & ThisType; // Type of 'this' in methods is D & M ->methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 116, 13)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 115, 24)) +>methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 115, 13)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 114, 24)) >ThisType : Symbol(ThisType, Decl(lib.d.ts, --, --)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 115, 22)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 115, 24)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 114, 22)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 114, 24)) } declare function makeObject(desc: ObjectDescriptor): D & M; ->makeObject : Symbol(makeObject, Decl(thisTypeInObjectLiterals2.ts, 118, 1)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 120, 28)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 120, 30)) ->desc : Symbol(desc, Decl(thisTypeInObjectLiterals2.ts, 120, 34)) ->ObjectDescriptor : Symbol(ObjectDescriptor, Decl(thisTypeInObjectLiterals2.ts, 110, 3)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 120, 28)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 120, 30)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 120, 28)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 120, 30)) +>makeObject : Symbol(makeObject, Decl(thisTypeInObjectLiterals2.ts, 117, 1)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 119, 28)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 119, 30)) +>desc : Symbol(desc, Decl(thisTypeInObjectLiterals2.ts, 119, 34)) +>ObjectDescriptor : Symbol(ObjectDescriptor, Decl(thisTypeInObjectLiterals2.ts, 109, 3)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 119, 28)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 119, 30)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 119, 28)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 119, 30)) let x1 = makeObject({ ->x1 : Symbol(x1, Decl(thisTypeInObjectLiterals2.ts, 122, 3)) ->makeObject : Symbol(makeObject, Decl(thisTypeInObjectLiterals2.ts, 118, 1)) +>x1 : Symbol(x1, Decl(thisTypeInObjectLiterals2.ts, 121, 3)) +>makeObject : Symbol(makeObject, Decl(thisTypeInObjectLiterals2.ts, 117, 1)) data: { x: 0, y: 0 }, ->data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 122, 21)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 123, 11)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 123, 17)) +>data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 121, 21)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 122, 11)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 122, 17)) methods: { ->methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 123, 25)) +>methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 122, 25)) moveBy(dx: number, dy: number) { ->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 124, 14)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 125, 15)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 125, 26)) +>moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 123, 14)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 124, 15)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 124, 26)) this.x += dx; // Strongly typed this ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 123, 11)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 123, 11)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 125, 15)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 122, 11)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 122, 11)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 124, 15)) this.y += dy; // Strongly typed this ->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 123, 17)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 123, 17)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 125, 26)) +>this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 122, 17)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 122, 17)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 124, 26)) } } }); @@ -416,59 +415,59 @@ let x1 = makeObject({ // some ThisType, 'this' is of type T. type ObjectDescriptor2 = ThisType & { ->ObjectDescriptor2 : Symbol(ObjectDescriptor2, Decl(thisTypeInObjectLiterals2.ts, 130, 3)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 135, 23)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 135, 25)) +>ObjectDescriptor2 : Symbol(ObjectDescriptor2, Decl(thisTypeInObjectLiterals2.ts, 129, 3)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 134, 23)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 134, 25)) >ThisType : Symbol(ThisType, Decl(lib.d.ts, --, --)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 135, 23)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 135, 25)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 134, 23)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 134, 25)) data?: D; ->data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 135, 50)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 135, 23)) +>data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 134, 50)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 134, 23)) methods?: M; ->methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 136, 13)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 135, 25)) +>methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 135, 13)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 134, 25)) } declare function makeObject2(desc: ObjectDescriptor): D & M; ->makeObject2 : Symbol(makeObject2, Decl(thisTypeInObjectLiterals2.ts, 138, 1)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 140, 29)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 140, 31)) ->desc : Symbol(desc, Decl(thisTypeInObjectLiterals2.ts, 140, 35)) ->ObjectDescriptor : Symbol(ObjectDescriptor, Decl(thisTypeInObjectLiterals2.ts, 110, 3)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 140, 29)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 140, 31)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 140, 29)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 140, 31)) +>makeObject2 : Symbol(makeObject2, Decl(thisTypeInObjectLiterals2.ts, 137, 1)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 139, 29)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 139, 31)) +>desc : Symbol(desc, Decl(thisTypeInObjectLiterals2.ts, 139, 35)) +>ObjectDescriptor : Symbol(ObjectDescriptor, Decl(thisTypeInObjectLiterals2.ts, 109, 3)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 139, 29)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 139, 31)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 139, 29)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 139, 31)) let x2 = makeObject2({ ->x2 : Symbol(x2, Decl(thisTypeInObjectLiterals2.ts, 142, 3)) ->makeObject2 : Symbol(makeObject2, Decl(thisTypeInObjectLiterals2.ts, 138, 1)) +>x2 : Symbol(x2, Decl(thisTypeInObjectLiterals2.ts, 141, 3)) +>makeObject2 : Symbol(makeObject2, Decl(thisTypeInObjectLiterals2.ts, 137, 1)) data: { x: 0, y: 0 }, ->data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 142, 22)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 143, 11)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 143, 17)) +>data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 141, 22)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 142, 11)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 142, 17)) methods: { ->methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 143, 25)) +>methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 142, 25)) moveBy(dx: number, dy: number) { ->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 144, 14)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 145, 15)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 145, 26)) +>moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 143, 14)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 144, 15)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 144, 26)) this.x += dx; // Strongly typed this ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 143, 11)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 143, 11)) ->dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 145, 15)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 142, 11)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 142, 11)) +>dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 144, 15)) this.y += dy; // Strongly typed this ->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 143, 17)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 143, 17)) ->dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 145, 26)) +>this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 142, 17)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 142, 17)) +>dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 144, 26)) } } }); @@ -476,307 +475,307 @@ let x2 = makeObject2({ // Check pattern similar to Object.defineProperty and Object.defineProperties type PropDesc = { ->PropDesc : Symbol(PropDesc, Decl(thisTypeInObjectLiterals2.ts, 150, 3)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 154, 14)) +>PropDesc : Symbol(PropDesc, Decl(thisTypeInObjectLiterals2.ts, 149, 3)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 153, 14)) value?: T; ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 154, 20)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 154, 14)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 153, 20)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 153, 14)) get?(): T; ->get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 155, 14)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 154, 14)) +>get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 154, 14)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 153, 14)) set?(value: T): void; ->set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 156, 14)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 157, 9)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 154, 14)) +>set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 155, 14)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 156, 9)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 153, 14)) } type PropDescMap = { ->PropDescMap : Symbol(PropDescMap, Decl(thisTypeInObjectLiterals2.ts, 158, 1)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 160, 17)) +>PropDescMap : Symbol(PropDescMap, Decl(thisTypeInObjectLiterals2.ts, 157, 1)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 159, 17)) [K in keyof T]: PropDesc; ->K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 161, 5)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 160, 17)) ->PropDesc : Symbol(PropDesc, Decl(thisTypeInObjectLiterals2.ts, 150, 3)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 160, 17)) ->K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 161, 5)) +>K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 160, 5)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 159, 17)) +>PropDesc : Symbol(PropDesc, Decl(thisTypeInObjectLiterals2.ts, 149, 3)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 159, 17)) +>K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 160, 5)) } declare function defineProp(obj: T, name: K, desc: PropDesc & ThisType): T & Record; ->defineProp : Symbol(defineProp, Decl(thisTypeInObjectLiterals2.ts, 162, 1)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 164, 28)) ->K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 164, 30)) ->U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 164, 48)) ->obj : Symbol(obj, Decl(thisTypeInObjectLiterals2.ts, 164, 52)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 164, 28)) ->name : Symbol(name, Decl(thisTypeInObjectLiterals2.ts, 164, 59)) ->K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 164, 30)) ->desc : Symbol(desc, Decl(thisTypeInObjectLiterals2.ts, 164, 68)) ->PropDesc : Symbol(PropDesc, Decl(thisTypeInObjectLiterals2.ts, 150, 3)) ->U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 164, 48)) +>defineProp : Symbol(defineProp, Decl(thisTypeInObjectLiterals2.ts, 161, 1)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 163, 28)) +>K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 163, 30)) +>U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 163, 48)) +>obj : Symbol(obj, Decl(thisTypeInObjectLiterals2.ts, 163, 52)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 163, 28)) +>name : Symbol(name, Decl(thisTypeInObjectLiterals2.ts, 163, 59)) +>K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 163, 30)) +>desc : Symbol(desc, Decl(thisTypeInObjectLiterals2.ts, 163, 68)) +>PropDesc : Symbol(PropDesc, Decl(thisTypeInObjectLiterals2.ts, 149, 3)) +>U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 163, 48)) >ThisType : Symbol(ThisType, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 164, 28)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 164, 28)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 163, 28)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 163, 28)) >Record : Symbol(Record, Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 164, 30)) ->U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 164, 48)) +>K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 163, 30)) +>U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 163, 48)) declare function defineProps(obj: T, descs: PropDescMap & ThisType): T & U; ->defineProps : Symbol(defineProps, Decl(thisTypeInObjectLiterals2.ts, 164, 120)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 166, 29)) ->U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 166, 31)) ->obj : Symbol(obj, Decl(thisTypeInObjectLiterals2.ts, 166, 35)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 166, 29)) ->descs : Symbol(descs, Decl(thisTypeInObjectLiterals2.ts, 166, 42)) ->PropDescMap : Symbol(PropDescMap, Decl(thisTypeInObjectLiterals2.ts, 158, 1)) ->U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 166, 31)) +>defineProps : Symbol(defineProps, Decl(thisTypeInObjectLiterals2.ts, 163, 120)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 165, 29)) +>U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 165, 31)) +>obj : Symbol(obj, Decl(thisTypeInObjectLiterals2.ts, 165, 35)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 165, 29)) +>descs : Symbol(descs, Decl(thisTypeInObjectLiterals2.ts, 165, 42)) +>PropDescMap : Symbol(PropDescMap, Decl(thisTypeInObjectLiterals2.ts, 157, 1)) +>U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 165, 31)) >ThisType : Symbol(ThisType, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 166, 29)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 166, 29)) ->U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 166, 31)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 165, 29)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 165, 29)) +>U : Symbol(U, Decl(thisTypeInObjectLiterals2.ts, 165, 31)) let p10 = defineProp(p1, "foo", { value: 42 }); ->p10 : Symbol(p10, Decl(thisTypeInObjectLiterals2.ts, 168, 3)) ->defineProp : Symbol(defineProp, Decl(thisTypeInObjectLiterals2.ts, 162, 1)) ->p1 : Symbol(p1, Decl(thisTypeInObjectLiterals2.ts, 36, 3)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 168, 33)) +>p10 : Symbol(p10, Decl(thisTypeInObjectLiterals2.ts, 167, 3)) +>defineProp : Symbol(defineProp, Decl(thisTypeInObjectLiterals2.ts, 161, 1)) +>p1 : Symbol(p1, Decl(thisTypeInObjectLiterals2.ts, 35, 3)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 167, 33)) p10.foo = p10.foo + 1; >p10.foo : Symbol(foo) ->p10 : Symbol(p10, Decl(thisTypeInObjectLiterals2.ts, 168, 3)) +>p10 : Symbol(p10, Decl(thisTypeInObjectLiterals2.ts, 167, 3)) >foo : Symbol(foo) >p10.foo : Symbol(foo) ->p10 : Symbol(p10, Decl(thisTypeInObjectLiterals2.ts, 168, 3)) +>p10 : Symbol(p10, Decl(thisTypeInObjectLiterals2.ts, 167, 3)) >foo : Symbol(foo) let p11 = defineProp(p1, "bar", { ->p11 : Symbol(p11, Decl(thisTypeInObjectLiterals2.ts, 171, 3)) ->defineProp : Symbol(defineProp, Decl(thisTypeInObjectLiterals2.ts, 162, 1)) ->p1 : Symbol(p1, Decl(thisTypeInObjectLiterals2.ts, 36, 3)) +>p11 : Symbol(p11, Decl(thisTypeInObjectLiterals2.ts, 170, 3)) +>defineProp : Symbol(defineProp, Decl(thisTypeInObjectLiterals2.ts, 161, 1)) +>p1 : Symbol(p1, Decl(thisTypeInObjectLiterals2.ts, 35, 3)) get() { ->get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 171, 33)) +>get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 170, 33)) return this.x; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) }, set(value: number) { ->set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 174, 6)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 175, 8)) +>set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 173, 6)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 174, 8)) this.x = value; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 175, 8)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 174, 8)) } }); p11.bar = p11.bar + 1; >p11.bar : Symbol(bar) ->p11 : Symbol(p11, Decl(thisTypeInObjectLiterals2.ts, 171, 3)) +>p11 : Symbol(p11, Decl(thisTypeInObjectLiterals2.ts, 170, 3)) >bar : Symbol(bar) >p11.bar : Symbol(bar) ->p11 : Symbol(p11, Decl(thisTypeInObjectLiterals2.ts, 171, 3)) +>p11 : Symbol(p11, Decl(thisTypeInObjectLiterals2.ts, 170, 3)) >bar : Symbol(bar) let p12 = defineProps(p1, { ->p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 181, 3)) ->defineProps : Symbol(defineProps, Decl(thisTypeInObjectLiterals2.ts, 164, 120)) ->p1 : Symbol(p1, Decl(thisTypeInObjectLiterals2.ts, 36, 3)) +>p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 180, 3)) +>defineProps : Symbol(defineProps, Decl(thisTypeInObjectLiterals2.ts, 163, 120)) +>p1 : Symbol(p1, Decl(thisTypeInObjectLiterals2.ts, 35, 3)) foo: { ->foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 181, 27)) +>foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 180, 27)) value: 42 ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 182, 10)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 181, 10)) }, bar: { ->bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 184, 6)) +>bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 183, 6)) get(): number { ->get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 185, 10)) +>get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 184, 10)) return this.x; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) }, set(value: number) { ->set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 188, 10)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 189, 12)) +>set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 187, 10)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 188, 12)) this.x = value; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 29, 12)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 29, 14)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 189, 12)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 188, 12)) } } }); p12.foo = p12.foo + 1; ->p12.foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 181, 27)) ->p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 181, 3)) ->foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 181, 27)) ->p12.foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 181, 27)) ->p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 181, 3)) ->foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 181, 27)) +>p12.foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 180, 27)) +>p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 180, 3)) +>foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 180, 27)) +>p12.foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 180, 27)) +>p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 180, 3)) +>foo : Symbol(foo, Decl(thisTypeInObjectLiterals2.ts, 180, 27)) p12.bar = p12.bar + 1; ->p12.bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 184, 6)) ->p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 181, 3)) ->bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 184, 6)) ->p12.bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 184, 6)) ->p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 181, 3)) ->bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 184, 6)) +>p12.bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 183, 6)) +>p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 180, 3)) +>bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 183, 6)) +>p12.bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 183, 6)) +>p12 : Symbol(p12, Decl(thisTypeInObjectLiterals2.ts, 180, 3)) +>bar : Symbol(bar, Decl(thisTypeInObjectLiterals2.ts, 183, 6)) // Proof of concept for typing of Vue.js type Accessors = { [K in keyof T]: (() => T[K]) | Computed }; ->Accessors : Symbol(Accessors, Decl(thisTypeInObjectLiterals2.ts, 195, 22)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 199, 15)) ->K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 199, 23)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 199, 15)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 199, 15)) ->K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 199, 23)) ->Computed : Symbol(Computed, Decl(thisTypeInObjectLiterals2.ts, 201, 39)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 199, 15)) ->K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 199, 23)) +>Accessors : Symbol(Accessors, Decl(thisTypeInObjectLiterals2.ts, 194, 22)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 198, 15)) +>K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 198, 23)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 198, 15)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 198, 15)) +>K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 198, 23)) +>Computed : Symbol(Computed, Decl(thisTypeInObjectLiterals2.ts, 200, 39)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 198, 15)) +>K : Symbol(K, Decl(thisTypeInObjectLiterals2.ts, 198, 23)) type Dictionary = { [x: string]: T } ->Dictionary : Symbol(Dictionary, Decl(thisTypeInObjectLiterals2.ts, 199, 70)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 201, 16)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 201, 24)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 201, 16)) +>Dictionary : Symbol(Dictionary, Decl(thisTypeInObjectLiterals2.ts, 198, 70)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 200, 16)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 200, 24)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 200, 16)) type Computed = { ->Computed : Symbol(Computed, Decl(thisTypeInObjectLiterals2.ts, 201, 39)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 203, 14)) +>Computed : Symbol(Computed, Decl(thisTypeInObjectLiterals2.ts, 200, 39)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 202, 14)) get?(): T; ->get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 203, 20)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 203, 14)) +>get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 202, 20)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 202, 14)) set?(value: T): void; ->set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 204, 14)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 205, 9)) ->T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 203, 14)) +>set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 203, 14)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 204, 9)) +>T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 202, 14)) } type VueOptions = ThisType & { ->VueOptions : Symbol(VueOptions, Decl(thisTypeInObjectLiterals2.ts, 206, 1)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 208, 16)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 208, 18)) ->P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 208, 21)) +>VueOptions : Symbol(VueOptions, Decl(thisTypeInObjectLiterals2.ts, 205, 1)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 207, 16)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 207, 18)) +>P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 207, 21)) >ThisType : Symbol(ThisType, Decl(lib.d.ts, --, --)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 208, 16)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 208, 18)) ->P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 208, 21)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 207, 16)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 207, 18)) +>P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 207, 21)) data?: D | (() => D); ->data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 208, 50)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 208, 16)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 208, 16)) +>data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 207, 50)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 207, 16)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 207, 16)) methods?: M; ->methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 209, 25)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 208, 18)) +>methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 208, 25)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 207, 18)) computed?: Accessors

; ->computed : Symbol(computed, Decl(thisTypeInObjectLiterals2.ts, 210, 16)) ->Accessors : Symbol(Accessors, Decl(thisTypeInObjectLiterals2.ts, 195, 22)) ->P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 208, 21)) +>computed : Symbol(computed, Decl(thisTypeInObjectLiterals2.ts, 209, 16)) +>Accessors : Symbol(Accessors, Decl(thisTypeInObjectLiterals2.ts, 194, 22)) +>P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 207, 21)) } declare const Vue: new (options: VueOptions) => D & M & P; ->Vue : Symbol(Vue, Decl(thisTypeInObjectLiterals2.ts, 214, 13)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 214, 24)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 214, 26)) ->P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 214, 29)) ->options : Symbol(options, Decl(thisTypeInObjectLiterals2.ts, 214, 33)) ->VueOptions : Symbol(VueOptions, Decl(thisTypeInObjectLiterals2.ts, 206, 1)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 214, 24)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 214, 26)) ->P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 214, 29)) ->D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 214, 24)) ->M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 214, 26)) ->P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 214, 29)) +>Vue : Symbol(Vue, Decl(thisTypeInObjectLiterals2.ts, 213, 13)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 213, 24)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 213, 26)) +>P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 213, 29)) +>options : Symbol(options, Decl(thisTypeInObjectLiterals2.ts, 213, 33)) +>VueOptions : Symbol(VueOptions, Decl(thisTypeInObjectLiterals2.ts, 205, 1)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 213, 24)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 213, 26)) +>P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 213, 29)) +>D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 213, 24)) +>M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 213, 26)) +>P : Symbol(P, Decl(thisTypeInObjectLiterals2.ts, 213, 29)) let vue = new Vue({ ->vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 216, 3)) ->Vue : Symbol(Vue, Decl(thisTypeInObjectLiterals2.ts, 214, 13)) +>vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 215, 3)) +>Vue : Symbol(Vue, Decl(thisTypeInObjectLiterals2.ts, 213, 13)) data: () => ({ x: 1, y: 2 }), ->data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 216, 19)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 217, 18)) ->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 217, 24)) +>data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 215, 19)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 216, 18)) +>y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 216, 24)) methods: { ->methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 217, 33)) +>methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 216, 33)) f(x: string) { ->f : Symbol(f, Decl(thisTypeInObjectLiterals2.ts, 218, 14)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 219, 10)) +>f : Symbol(f, Decl(thisTypeInObjectLiterals2.ts, 217, 14)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 218, 10)) return this.x; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 217, 18)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 217, 18)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 216, 18)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 216, 18)) } }, computed: { ->computed : Symbol(computed, Decl(thisTypeInObjectLiterals2.ts, 222, 6)) +>computed : Symbol(computed, Decl(thisTypeInObjectLiterals2.ts, 221, 6)) test(): number { ->test : Symbol(test, Decl(thisTypeInObjectLiterals2.ts, 223, 15)) +>test : Symbol(test, Decl(thisTypeInObjectLiterals2.ts, 222, 15)) return this.x; ->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 217, 18)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 217, 18)) +>this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 216, 18)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 216, 18)) }, hello: { ->hello : Symbol(hello, Decl(thisTypeInObjectLiterals2.ts, 226, 10)) +>hello : Symbol(hello, Decl(thisTypeInObjectLiterals2.ts, 225, 10)) get() { ->get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 227, 16)) +>get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 226, 16)) return "hi"; }, set(value: string) { ->set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 230, 14)) ->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 231, 16)) +>set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 229, 14)) +>value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 230, 16)) } } } }); vue; ->vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 216, 3)) +>vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 215, 3)) vue.x; ->vue.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 217, 18)) ->vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 216, 3)) ->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 217, 18)) +>vue.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 216, 18)) +>vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 215, 3)) +>x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 216, 18)) vue.f("abc"); ->vue.f : Symbol(f, Decl(thisTypeInObjectLiterals2.ts, 218, 14)) ->vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 216, 3)) ->f : Symbol(f, Decl(thisTypeInObjectLiterals2.ts, 218, 14)) +>vue.f : Symbol(f, Decl(thisTypeInObjectLiterals2.ts, 217, 14)) +>vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 215, 3)) +>f : Symbol(f, Decl(thisTypeInObjectLiterals2.ts, 217, 14)) vue.test; ->vue.test : Symbol(test, Decl(thisTypeInObjectLiterals2.ts, 223, 15)) ->vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 216, 3)) ->test : Symbol(test, Decl(thisTypeInObjectLiterals2.ts, 223, 15)) +>vue.test : Symbol(test, Decl(thisTypeInObjectLiterals2.ts, 222, 15)) +>vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 215, 3)) +>test : Symbol(test, Decl(thisTypeInObjectLiterals2.ts, 222, 15)) vue.hello; ->vue.hello : Symbol(hello, Decl(thisTypeInObjectLiterals2.ts, 226, 10)) ->vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 216, 3)) ->hello : Symbol(hello, Decl(thisTypeInObjectLiterals2.ts, 226, 10)) +>vue.hello : Symbol(hello, Decl(thisTypeInObjectLiterals2.ts, 225, 10)) +>vue : Symbol(vue, Decl(thisTypeInObjectLiterals2.ts, 215, 3)) +>hello : Symbol(hello, Decl(thisTypeInObjectLiterals2.ts, 225, 10)) diff --git a/tests/baselines/reference/thisTypeInObjectLiterals2.types b/tests/baselines/reference/thisTypeInObjectLiterals2.types index 2742ad2c408fd..746ca0eb264ac 100644 --- a/tests/baselines/reference/thisTypeInObjectLiterals2.types +++ b/tests/baselines/reference/thisTypeInObjectLiterals2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/types/thisType/thisTypeInObjectLiterals2.ts === - // In methods of an object literal with no contextual type, 'this' has the type // of the object literal. diff --git a/tests/baselines/reference/throwInEnclosingStatements.js b/tests/baselines/reference/throwInEnclosingStatements.js index 83928d71bff99..eb4da2e6c4d13 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.js +++ b/tests/baselines/reference/throwInEnclosingStatements.js @@ -1,5 +1,4 @@ //// [throwInEnclosingStatements.ts] - function fn(x) { throw x; } diff --git a/tests/baselines/reference/throwInEnclosingStatements.symbols b/tests/baselines/reference/throwInEnclosingStatements.symbols index 63ed9dde5784a..3071c8efd37f3 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.symbols +++ b/tests/baselines/reference/throwInEnclosingStatements.symbols @@ -1,92 +1,91 @@ === tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts === - function fn(x) { >fn : Symbol(fn, Decl(throwInEnclosingStatements.ts, 0, 0)) ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 1, 12)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 0, 12)) throw x; ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 1, 12)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 0, 12)) } (x: T) => { throw x; } ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 5, 1)) ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 5, 4)) ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 5, 1)) ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 5, 4)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4)) var y: string; ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) switch (y) { ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) case 'a': throw y; ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) default: throw y; ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) } var z = 0; ->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3)) +>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3)) while (z < 10) { ->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3)) +>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3)) throw z; ->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3)) +>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3)) } for (var i = 0; ;) { throw i; } ->i : Symbol(i, Decl(throwInEnclosingStatements.ts, 20, 8)) ->i : Symbol(i, Decl(throwInEnclosingStatements.ts, 20, 8)) +>i : Symbol(i, Decl(throwInEnclosingStatements.ts, 19, 8)) +>i : Symbol(i, Decl(throwInEnclosingStatements.ts, 19, 8)) for (var idx in {}) { throw idx; } ->idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 22, 8)) ->idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 22, 8)) +>idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8)) +>idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8)) do { throw null; }while(true) var j = 0; ->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3)) +>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3)) while (j < 0) { throw j; } ->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3)) ->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3)) +>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3)) +>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3)) class C { ->C : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26)) ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 29, 8)) +>C : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 28, 8)) private value: T; ->value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 29, 12)) ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 29, 8)) +>value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 28, 12)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 28, 8)) biz() { ->biz : Symbol(C.biz, Decl(throwInEnclosingStatements.ts, 30, 21)) +>biz : Symbol(C.biz, Decl(throwInEnclosingStatements.ts, 29, 21)) throw this.value; ->this.value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 29, 12)) ->this : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26)) ->value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 29, 12)) +>this.value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 28, 12)) +>this : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26)) +>value : Symbol(C.value, Decl(throwInEnclosingStatements.ts, 28, 12)) } constructor() { throw this; ->this : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26)) +>this : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26)) } } var aa = { ->aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 40, 3)) +>aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 39, 3)) id:12, ->id : Symbol(id, Decl(throwInEnclosingStatements.ts, 40, 10)) +>id : Symbol(id, Decl(throwInEnclosingStatements.ts, 39, 10)) biz() { ->biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 41, 10)) +>biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 40, 10)) throw this; } diff --git a/tests/baselines/reference/throwInEnclosingStatements.types b/tests/baselines/reference/throwInEnclosingStatements.types index 2d99ac435aebf..e031d00147d96 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.types +++ b/tests/baselines/reference/throwInEnclosingStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts === - function fn(x) { >fn : (x: any) => void >x : any diff --git a/tests/baselines/reference/throwStatements.js b/tests/baselines/reference/throwStatements.js index eb25d0a895bc3..0773ecba845ab 100644 --- a/tests/baselines/reference/throwStatements.js +++ b/tests/baselines/reference/throwStatements.js @@ -1,5 +1,4 @@ //// [throwStatements.ts] - // all legal interface I { diff --git a/tests/baselines/reference/throwStatements.symbols b/tests/baselines/reference/throwStatements.symbols index 854fbcbe90b45..e4d09aeb0e831 100644 --- a/tests/baselines/reference/throwStatements.symbols +++ b/tests/baselines/reference/throwStatements.symbols @@ -1,185 +1,184 @@ === tests/cases/conformance/statements/throwStatements/throwStatements.ts === - // all legal interface I { >I : Symbol(I, Decl(throwStatements.ts, 0, 0)) id: number; ->id : Symbol(I.id, Decl(throwStatements.ts, 3, 13)) +>id : Symbol(I.id, Decl(throwStatements.ts, 2, 13)) } class C implements I { ->C : Symbol(C, Decl(throwStatements.ts, 5, 1)) +>C : Symbol(C, Decl(throwStatements.ts, 4, 1)) >I : Symbol(I, Decl(throwStatements.ts, 0, 0)) id: number; ->id : Symbol(C.id, Decl(throwStatements.ts, 7, 22)) +>id : Symbol(C.id, Decl(throwStatements.ts, 6, 22)) } class D{ ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) ->T : Symbol(T, Decl(throwStatements.ts, 11, 8)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>T : Symbol(T, Decl(throwStatements.ts, 10, 8)) source: T; ->source : Symbol(D.source, Decl(throwStatements.ts, 11, 11)) ->T : Symbol(T, Decl(throwStatements.ts, 11, 8)) +>source : Symbol(D.source, Decl(throwStatements.ts, 10, 11)) +>T : Symbol(T, Decl(throwStatements.ts, 10, 8)) recurse: D; ->recurse : Symbol(D.recurse, Decl(throwStatements.ts, 12, 14)) ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) ->T : Symbol(T, Decl(throwStatements.ts, 11, 8)) +>recurse : Symbol(D.recurse, Decl(throwStatements.ts, 11, 14)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>T : Symbol(T, Decl(throwStatements.ts, 10, 8)) wrapped: D> ->wrapped : Symbol(D.wrapped, Decl(throwStatements.ts, 13, 18)) ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) ->T : Symbol(T, Decl(throwStatements.ts, 11, 8)) +>wrapped : Symbol(D.wrapped, Decl(throwStatements.ts, 12, 18)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>T : Symbol(T, Decl(throwStatements.ts, 10, 8)) } function F(x: string): number { return 42; } ->F : Symbol(F, Decl(throwStatements.ts, 15, 1)) ->x : Symbol(x, Decl(throwStatements.ts, 17, 11)) +>F : Symbol(F, Decl(throwStatements.ts, 14, 1)) +>x : Symbol(x, Decl(throwStatements.ts, 16, 11)) module M { ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) export class A { ->A : Symbol(A, Decl(throwStatements.ts, 19, 10)) +>A : Symbol(A, Decl(throwStatements.ts, 18, 10)) name: string; ->name : Symbol(A.name, Decl(throwStatements.ts, 20, 20)) +>name : Symbol(A.name, Decl(throwStatements.ts, 19, 20)) } export function F2(x: number): string { return x.toString(); } ->F2 : Symbol(F2, Decl(throwStatements.ts, 22, 5)) ->x : Symbol(x, Decl(throwStatements.ts, 24, 23)) +>F2 : Symbol(F2, Decl(throwStatements.ts, 21, 5)) +>x : Symbol(x, Decl(throwStatements.ts, 23, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(throwStatements.ts, 24, 23)) +>x : Symbol(x, Decl(throwStatements.ts, 23, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } var aNumber = 9.9; ->aNumber : Symbol(aNumber, Decl(throwStatements.ts, 27, 3)) +>aNumber : Symbol(aNumber, Decl(throwStatements.ts, 26, 3)) throw aNumber; ->aNumber : Symbol(aNumber, Decl(throwStatements.ts, 27, 3)) +>aNumber : Symbol(aNumber, Decl(throwStatements.ts, 26, 3)) var aString = 'this is a string'; ->aString : Symbol(aString, Decl(throwStatements.ts, 29, 3)) +>aString : Symbol(aString, Decl(throwStatements.ts, 28, 3)) throw aString; ->aString : Symbol(aString, Decl(throwStatements.ts, 29, 3)) +>aString : Symbol(aString, Decl(throwStatements.ts, 28, 3)) var aDate = new Date(12); ->aDate : Symbol(aDate, Decl(throwStatements.ts, 31, 3)) +>aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw aDate; ->aDate : Symbol(aDate, Decl(throwStatements.ts, 31, 3)) +>aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3)) var anObject = new Object(); ->anObject : Symbol(anObject, Decl(throwStatements.ts, 33, 3)) +>anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw anObject; ->anObject : Symbol(anObject, Decl(throwStatements.ts, 33, 3)) +>anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3)) var anAny = null; ->anAny : Symbol(anAny, Decl(throwStatements.ts, 36, 3)) +>anAny : Symbol(anAny, Decl(throwStatements.ts, 35, 3)) throw anAny; ->anAny : Symbol(anAny, Decl(throwStatements.ts, 36, 3)) +>anAny : Symbol(anAny, Decl(throwStatements.ts, 35, 3)) var anOtherAny = new C(); ->anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 38, 3)) ->C : Symbol(C, Decl(throwStatements.ts, 5, 1)) +>anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 37, 3)) +>C : Symbol(C, Decl(throwStatements.ts, 4, 1)) throw anOtherAny; ->anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 38, 3)) +>anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 37, 3)) var anUndefined = undefined; ->anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 40, 3)) +>anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 39, 3)) >undefined : Symbol(undefined) throw anUndefined; ->anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 40, 3)) +>anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 39, 3)) var aClass = new C(); ->aClass : Symbol(aClass, Decl(throwStatements.ts, 43, 3)) ->C : Symbol(C, Decl(throwStatements.ts, 5, 1)) +>aClass : Symbol(aClass, Decl(throwStatements.ts, 42, 3)) +>C : Symbol(C, Decl(throwStatements.ts, 4, 1)) throw aClass; ->aClass : Symbol(aClass, Decl(throwStatements.ts, 43, 3)) +>aClass : Symbol(aClass, Decl(throwStatements.ts, 42, 3)) var aGenericClass = new D(); ->aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 45, 3)) ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) +>aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 44, 3)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) throw aGenericClass; ->aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 45, 3)) +>aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 44, 3)) var anObjectLiteral = { id: 12 }; ->anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 47, 3)) ->id : Symbol(id, Decl(throwStatements.ts, 47, 23)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3)) +>id : Symbol(id, Decl(throwStatements.ts, 46, 23)) throw anObjectLiteral; ->anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 47, 3)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3)) var aFunction = F; ->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3)) ->F : Symbol(F, Decl(throwStatements.ts, 15, 1)) +>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3)) +>F : Symbol(F, Decl(throwStatements.ts, 14, 1)) throw aFunction; ->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3)) +>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3)) throw aFunction(''); ->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3)) +>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3)) var aLambda = (x) => 2; ->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3)) ->x : Symbol(x, Decl(throwStatements.ts, 53, 15)) +>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3)) +>x : Symbol(x, Decl(throwStatements.ts, 52, 15)) throw aLambda; ->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3)) +>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3)) throw aLambda(1); ->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3)) +>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3)) var aModule = M; ->aModule : Symbol(aModule, Decl(throwStatements.ts, 57, 3)) ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) +>aModule : Symbol(aModule, Decl(throwStatements.ts, 56, 3)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) throw aModule; ->aModule : Symbol(aModule, Decl(throwStatements.ts, 57, 3)) +>aModule : Symbol(aModule, Decl(throwStatements.ts, 56, 3)) throw typeof M; ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) var aClassInModule = new M.A(); ->aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 60, 3)) ->M.A : Symbol(M.A, Decl(throwStatements.ts, 19, 10)) ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) ->A : Symbol(M.A, Decl(throwStatements.ts, 19, 10)) +>aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 59, 3)) +>M.A : Symbol(M.A, Decl(throwStatements.ts, 18, 10)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) +>A : Symbol(M.A, Decl(throwStatements.ts, 18, 10)) throw aClassInModule; ->aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 60, 3)) +>aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 59, 3)) var aFunctionInModule = M.F2; ->aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 62, 3)) ->M.F2 : Symbol(M.F2, Decl(throwStatements.ts, 22, 5)) ->M : Symbol(M, Decl(throwStatements.ts, 17, 44)) ->F2 : Symbol(M.F2, Decl(throwStatements.ts, 22, 5)) +>aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 61, 3)) +>M.F2 : Symbol(M.F2, Decl(throwStatements.ts, 21, 5)) +>M : Symbol(M, Decl(throwStatements.ts, 16, 44)) +>F2 : Symbol(M.F2, Decl(throwStatements.ts, 21, 5)) throw aFunctionInModule; ->aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 62, 3)) +>aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 61, 3)) // no initializer or annotation, so this is an 'any' var x; ->x : Symbol(x, Decl(throwStatements.ts, 66, 3)) +>x : Symbol(x, Decl(throwStatements.ts, 65, 3)) throw x; ->x : Symbol(x, Decl(throwStatements.ts, 66, 3)) +>x : Symbol(x, Decl(throwStatements.ts, 65, 3)) // literals throw 0.0; @@ -191,13 +190,13 @@ throw undefined; throw 'a string'; throw function () { return 'a string' }; throw (x:T) => 42; ->T : Symbol(T, Decl(throwStatements.ts, 76, 7)) ->x : Symbol(x, Decl(throwStatements.ts, 76, 10)) ->T : Symbol(T, Decl(throwStatements.ts, 76, 7)) +>T : Symbol(T, Decl(throwStatements.ts, 75, 7)) +>x : Symbol(x, Decl(throwStatements.ts, 75, 10)) +>T : Symbol(T, Decl(throwStatements.ts, 75, 7)) throw { x: 12, y: 13 }; ->x : Symbol(x, Decl(throwStatements.ts, 77, 7)) ->y : Symbol(y, Decl(throwStatements.ts, 77, 14)) +>x : Symbol(x, Decl(throwStatements.ts, 76, 7)) +>y : Symbol(y, Decl(throwStatements.ts, 76, 14)) throw []; throw ['a', ['b']]; @@ -206,11 +205,11 @@ throw new Date(); >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw new C(); ->C : Symbol(C, Decl(throwStatements.ts, 5, 1)) +>C : Symbol(C, Decl(throwStatements.ts, 4, 1)) throw new Object(); >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw new D(); ->D : Symbol(D, Decl(throwStatements.ts, 9, 1)) +>D : Symbol(D, Decl(throwStatements.ts, 8, 1)) diff --git a/tests/baselines/reference/throwStatements.types b/tests/baselines/reference/throwStatements.types index 3c8fd64ee3978..9ad2d954f27d6 100644 --- a/tests/baselines/reference/throwStatements.types +++ b/tests/baselines/reference/throwStatements.types @@ -1,5 +1,4 @@ === tests/cases/conformance/statements/throwStatements/throwStatements.ts === - // all legal interface I { diff --git a/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt b/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt index b502eaad7e58d..32c1a470bc380 100644 --- a/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt +++ b/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt @@ -2,8 +2,6 @@ tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(5,19): error TS Type 'string | number' is not assignable to type 'number'. Type 'string' is not assignable to type 'number'. tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(6,19): error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'. - Type 'string | number' is not assignable to type 'number'. - Type 'string' is not assignable to type 'number'. ==== tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts (2 errors) ==== @@ -19,8 +17,6 @@ tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(6,19): error TS this.test([1, 2, "hi", 5]); ~~~~~~~~~~~~~~~ !!! error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'. -!!! error TS2345: Type 'string | number' is not assignable to type 'number'. -!!! error TS2345: Type 'string' is not assignable to type 'number'. } } \ No newline at end of file diff --git a/tests/baselines/reference/trailingCommasES3.js b/tests/baselines/reference/trailingCommasES3.js index 554390a83eae9..dba0ec31ad702 100644 --- a/tests/baselines/reference/trailingCommasES3.js +++ b/tests/baselines/reference/trailingCommasES3.js @@ -1,5 +1,4 @@ //// [trailingCommasES3.ts] - var o1 = { a: 1, b: 2 }; var o2 = { a: 1, b: 2, }; var o3 = { a: 1, }; diff --git a/tests/baselines/reference/trailingCommasES3.symbols b/tests/baselines/reference/trailingCommasES3.symbols index f176c9765c957..aae024697098b 100644 --- a/tests/baselines/reference/trailingCommasES3.symbols +++ b/tests/baselines/reference/trailingCommasES3.symbols @@ -1,37 +1,36 @@ === tests/cases/compiler/trailingCommasES3.ts === - var o1 = { a: 1, b: 2 }; ->o1 : Symbol(o1, Decl(trailingCommasES3.ts, 1, 3)) ->a : Symbol(a, Decl(trailingCommasES3.ts, 1, 10)) ->b : Symbol(b, Decl(trailingCommasES3.ts, 1, 16)) +>o1 : Symbol(o1, Decl(trailingCommasES3.ts, 0, 3)) +>a : Symbol(a, Decl(trailingCommasES3.ts, 0, 10)) +>b : Symbol(b, Decl(trailingCommasES3.ts, 0, 16)) var o2 = { a: 1, b: 2, }; ->o2 : Symbol(o2, Decl(trailingCommasES3.ts, 2, 3)) ->a : Symbol(a, Decl(trailingCommasES3.ts, 2, 10)) ->b : Symbol(b, Decl(trailingCommasES3.ts, 2, 16)) +>o2 : Symbol(o2, Decl(trailingCommasES3.ts, 1, 3)) +>a : Symbol(a, Decl(trailingCommasES3.ts, 1, 10)) +>b : Symbol(b, Decl(trailingCommasES3.ts, 1, 16)) var o3 = { a: 1, }; ->o3 : Symbol(o3, Decl(trailingCommasES3.ts, 3, 3)) ->a : Symbol(a, Decl(trailingCommasES3.ts, 3, 10)) +>o3 : Symbol(o3, Decl(trailingCommasES3.ts, 2, 3)) +>a : Symbol(a, Decl(trailingCommasES3.ts, 2, 10)) var o4 = {}; ->o4 : Symbol(o4, Decl(trailingCommasES3.ts, 4, 3)) +>o4 : Symbol(o4, Decl(trailingCommasES3.ts, 3, 3)) var a1 = [1, 2]; ->a1 : Symbol(a1, Decl(trailingCommasES3.ts, 6, 3)) +>a1 : Symbol(a1, Decl(trailingCommasES3.ts, 5, 3)) var a2 = [1, 2, ]; ->a2 : Symbol(a2, Decl(trailingCommasES3.ts, 7, 3)) +>a2 : Symbol(a2, Decl(trailingCommasES3.ts, 6, 3)) var a3 = [1, ]; ->a3 : Symbol(a3, Decl(trailingCommasES3.ts, 8, 3)) +>a3 : Symbol(a3, Decl(trailingCommasES3.ts, 7, 3)) var a4 = []; ->a4 : Symbol(a4, Decl(trailingCommasES3.ts, 9, 3)) +>a4 : Symbol(a4, Decl(trailingCommasES3.ts, 8, 3)) var a5 = [1, , ]; ->a5 : Symbol(a5, Decl(trailingCommasES3.ts, 10, 3)) +>a5 : Symbol(a5, Decl(trailingCommasES3.ts, 9, 3)) var a6 = [, , ]; ->a6 : Symbol(a6, Decl(trailingCommasES3.ts, 11, 3)) +>a6 : Symbol(a6, Decl(trailingCommasES3.ts, 10, 3)) diff --git a/tests/baselines/reference/trailingCommasES3.types b/tests/baselines/reference/trailingCommasES3.types index 21e397a1c4629..c2f689b31526e 100644 --- a/tests/baselines/reference/trailingCommasES3.types +++ b/tests/baselines/reference/trailingCommasES3.types @@ -1,5 +1,4 @@ === tests/cases/compiler/trailingCommasES3.ts === - var o1 = { a: 1, b: 2 }; >o1 : { a: number; b: number; } >{ a: 1, b: 2 } : { a: number; b: number; } diff --git a/tests/baselines/reference/trailingCommasES5.js b/tests/baselines/reference/trailingCommasES5.js index e54e911189a7d..29b32206c7681 100644 --- a/tests/baselines/reference/trailingCommasES5.js +++ b/tests/baselines/reference/trailingCommasES5.js @@ -1,5 +1,4 @@ //// [trailingCommasES5.ts] - var o1 = { a: 1, b: 2 }; var o2 = { a: 1, b: 2, }; var o3 = { a: 1, }; diff --git a/tests/baselines/reference/trailingCommasES5.symbols b/tests/baselines/reference/trailingCommasES5.symbols index 1cf7a32154769..d65b6d81b1315 100644 --- a/tests/baselines/reference/trailingCommasES5.symbols +++ b/tests/baselines/reference/trailingCommasES5.symbols @@ -1,37 +1,36 @@ === tests/cases/compiler/trailingCommasES5.ts === - var o1 = { a: 1, b: 2 }; ->o1 : Symbol(o1, Decl(trailingCommasES5.ts, 1, 3)) ->a : Symbol(a, Decl(trailingCommasES5.ts, 1, 10)) ->b : Symbol(b, Decl(trailingCommasES5.ts, 1, 16)) +>o1 : Symbol(o1, Decl(trailingCommasES5.ts, 0, 3)) +>a : Symbol(a, Decl(trailingCommasES5.ts, 0, 10)) +>b : Symbol(b, Decl(trailingCommasES5.ts, 0, 16)) var o2 = { a: 1, b: 2, }; ->o2 : Symbol(o2, Decl(trailingCommasES5.ts, 2, 3)) ->a : Symbol(a, Decl(trailingCommasES5.ts, 2, 10)) ->b : Symbol(b, Decl(trailingCommasES5.ts, 2, 16)) +>o2 : Symbol(o2, Decl(trailingCommasES5.ts, 1, 3)) +>a : Symbol(a, Decl(trailingCommasES5.ts, 1, 10)) +>b : Symbol(b, Decl(trailingCommasES5.ts, 1, 16)) var o3 = { a: 1, }; ->o3 : Symbol(o3, Decl(trailingCommasES5.ts, 3, 3)) ->a : Symbol(a, Decl(trailingCommasES5.ts, 3, 10)) +>o3 : Symbol(o3, Decl(trailingCommasES5.ts, 2, 3)) +>a : Symbol(a, Decl(trailingCommasES5.ts, 2, 10)) var o4 = {}; ->o4 : Symbol(o4, Decl(trailingCommasES5.ts, 4, 3)) +>o4 : Symbol(o4, Decl(trailingCommasES5.ts, 3, 3)) var a1 = [1, 2]; ->a1 : Symbol(a1, Decl(trailingCommasES5.ts, 6, 3)) +>a1 : Symbol(a1, Decl(trailingCommasES5.ts, 5, 3)) var a2 = [1, 2, ]; ->a2 : Symbol(a2, Decl(trailingCommasES5.ts, 7, 3)) +>a2 : Symbol(a2, Decl(trailingCommasES5.ts, 6, 3)) var a3 = [1, ]; ->a3 : Symbol(a3, Decl(trailingCommasES5.ts, 8, 3)) +>a3 : Symbol(a3, Decl(trailingCommasES5.ts, 7, 3)) var a4 = []; ->a4 : Symbol(a4, Decl(trailingCommasES5.ts, 9, 3)) +>a4 : Symbol(a4, Decl(trailingCommasES5.ts, 8, 3)) var a5 = [1, , ]; ->a5 : Symbol(a5, Decl(trailingCommasES5.ts, 10, 3)) +>a5 : Symbol(a5, Decl(trailingCommasES5.ts, 9, 3)) var a6 = [, , ]; ->a6 : Symbol(a6, Decl(trailingCommasES5.ts, 11, 3)) +>a6 : Symbol(a6, Decl(trailingCommasES5.ts, 10, 3)) diff --git a/tests/baselines/reference/trailingCommasES5.types b/tests/baselines/reference/trailingCommasES5.types index 22d4fb3778063..3b5f9638a5baa 100644 --- a/tests/baselines/reference/trailingCommasES5.types +++ b/tests/baselines/reference/trailingCommasES5.types @@ -1,5 +1,4 @@ === tests/cases/compiler/trailingCommasES5.ts === - var o1 = { a: 1, b: 2 }; >o1 : { a: number; b: number; } >{ a: 1, b: 2 } : { a: number; b: number; } diff --git a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.js b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.js index 495e9354024e6..64df1ec5a7512 100644 --- a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.js +++ b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.js @@ -1,5 +1,4 @@ //// [trailingCommasInFunctionParametersAndArguments.ts] - function f1(x,) {} f1(1,); diff --git a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.symbols b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.symbols index 2ee58a747b72d..2d7a1f07e5a2e 100644 --- a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.symbols +++ b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.symbols @@ -1,57 +1,56 @@ === tests/cases/conformance/es7/trailingCommasInFunctionParametersAndArguments.ts === - function f1(x,) {} >f1 : Symbol(f1, Decl(trailingCommasInFunctionParametersAndArguments.ts, 0, 0)) ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 1, 12)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 0, 12)) f1(1,); >f1 : Symbol(f1, Decl(trailingCommasInFunctionParametersAndArguments.ts, 0, 0)) function f2(...args,) {} ->f2 : Symbol(f2, Decl(trailingCommasInFunctionParametersAndArguments.ts, 3, 7)) ->args : Symbol(args, Decl(trailingCommasInFunctionParametersAndArguments.ts, 5, 12)) +>f2 : Symbol(f2, Decl(trailingCommasInFunctionParametersAndArguments.ts, 2, 7)) +>args : Symbol(args, Decl(trailingCommasInFunctionParametersAndArguments.ts, 4, 12)) f2(...[],); ->f2 : Symbol(f2, Decl(trailingCommasInFunctionParametersAndArguments.ts, 3, 7)) +>f2 : Symbol(f2, Decl(trailingCommasInFunctionParametersAndArguments.ts, 2, 7)) // Not confused by overloads declare function f3(x, ): number; ->f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 7, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 33)) ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 20)) +>f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 6, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 33)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 20)) declare function f3(x, y,): string; ->f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 7, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 33)) ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 11, 20)) ->y : Symbol(y, Decl(trailingCommasInFunctionParametersAndArguments.ts, 11, 22)) +>f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 6, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 33)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 20)) +>y : Symbol(y, Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 22)) f3(1,); ->f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 7, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 33)) +>f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 6, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 33)) f3(1, 2,); ->f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 7, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 10, 33)) +>f3 : Symbol(f3, Decl(trailingCommasInFunctionParametersAndArguments.ts, 6, 11), Decl(trailingCommasInFunctionParametersAndArguments.ts, 9, 33)) // Works for constructors too class X { ->X : Symbol(X, Decl(trailingCommasInFunctionParametersAndArguments.ts, 14, 18)) +>X : Symbol(X, Decl(trailingCommasInFunctionParametersAndArguments.ts, 13, 18)) constructor(a,) { } ->a : Symbol(a, Decl(trailingCommasInFunctionParametersAndArguments.ts, 18, 16)) +>a : Symbol(a, Decl(trailingCommasInFunctionParametersAndArguments.ts, 17, 16)) // See trailingCommasInGetter.ts set x(value,) { } ->x : Symbol(X.x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 18, 23)) ->value : Symbol(value, Decl(trailingCommasInFunctionParametersAndArguments.ts, 20, 10)) +>x : Symbol(X.x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 17, 23)) +>value : Symbol(value, Decl(trailingCommasInFunctionParametersAndArguments.ts, 19, 10)) } interface Y { ->Y : Symbol(Y, Decl(trailingCommasInFunctionParametersAndArguments.ts, 21, 1)) +>Y : Symbol(Y, Decl(trailingCommasInFunctionParametersAndArguments.ts, 20, 1)) new(x,); ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 23, 8)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 22, 8)) (x,); ->x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 24, 5)) +>x : Symbol(x, Decl(trailingCommasInFunctionParametersAndArguments.ts, 23, 5)) } new X(1,); ->X : Symbol(X, Decl(trailingCommasInFunctionParametersAndArguments.ts, 14, 18)) +>X : Symbol(X, Decl(trailingCommasInFunctionParametersAndArguments.ts, 13, 18)) diff --git a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.types b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.types index 00cca0b5e8739..9df4b0afb5025 100644 --- a/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.types +++ b/tests/baselines/reference/trailingCommasInFunctionParametersAndArguments.types @@ -1,5 +1,4 @@ === tests/cases/conformance/es7/trailingCommasInFunctionParametersAndArguments.ts === - function f1(x,) {} >f1 : (x: any) => void >x : any diff --git a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.js b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.js index 4f2e166627531..59b85b2b8cce2 100644 --- a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.js +++ b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.js @@ -1,5 +1,4 @@ //// [transformArrowInBlockScopedLoopVarInitializer.ts] - // https://github.com/Microsoft/TypeScript/issues/11236 while (true) { diff --git a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.symbols b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.symbols index 4c5e2cf686e02..c105ad68a3a04 100644 --- a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.symbols +++ b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.symbols @@ -1,12 +1,11 @@ === tests/cases/compiler/transformArrowInBlockScopedLoopVarInitializer.ts === - // https://github.com/Microsoft/TypeScript/issues/11236 while (true) { let local = null; ->local : Symbol(local, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 4, 7)) +>local : Symbol(local, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 3, 7)) var a = () => local; // <-- Lambda should be converted to function() ->a : Symbol(a, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 5, 7)) ->local : Symbol(local, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 4, 7)) +>a : Symbol(a, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 4, 7)) +>local : Symbol(local, Decl(transformArrowInBlockScopedLoopVarInitializer.ts, 3, 7)) } diff --git a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.types b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.types index 6c6769dadbb92..bacbb82909624 100644 --- a/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.types +++ b/tests/baselines/reference/transformArrowInBlockScopedLoopVarInitializer.types @@ -1,5 +1,4 @@ === tests/cases/compiler/transformArrowInBlockScopedLoopVarInitializer.ts === - // https://github.com/Microsoft/TypeScript/issues/11236 while (true) >true : true diff --git a/tests/baselines/reference/transformsElideNullUndefinedType.js b/tests/baselines/reference/transformsElideNullUndefinedType.js index 63bc77559c127..ab0f98bcfc23d 100644 --- a/tests/baselines/reference/transformsElideNullUndefinedType.js +++ b/tests/baselines/reference/transformsElideNullUndefinedType.js @@ -1,5 +1,4 @@ //// [transformsElideNullUndefinedType.ts] - var v0: null; var v1: undefined; diff --git a/tests/baselines/reference/transformsElideNullUndefinedType.symbols b/tests/baselines/reference/transformsElideNullUndefinedType.symbols index b651784a61ca8..a3e3f60aa6404 100644 --- a/tests/baselines/reference/transformsElideNullUndefinedType.symbols +++ b/tests/baselines/reference/transformsElideNullUndefinedType.symbols @@ -1,143 +1,142 @@ === tests/cases/compiler/transformsElideNullUndefinedType.ts === - var v0: null; ->v0 : Symbol(v0, Decl(transformsElideNullUndefinedType.ts, 1, 3)) +>v0 : Symbol(v0, Decl(transformsElideNullUndefinedType.ts, 0, 3)) var v1: undefined; ->v1 : Symbol(v1, Decl(transformsElideNullUndefinedType.ts, 2, 3)) +>v1 : Symbol(v1, Decl(transformsElideNullUndefinedType.ts, 1, 3)) function f0(): null { return null; } ->f0 : Symbol(f0, Decl(transformsElideNullUndefinedType.ts, 2, 18)) +>f0 : Symbol(f0, Decl(transformsElideNullUndefinedType.ts, 1, 18)) function f1(): undefined { return undefined; } ->f1 : Symbol(f1, Decl(transformsElideNullUndefinedType.ts, 4, 36)) +>f1 : Symbol(f1, Decl(transformsElideNullUndefinedType.ts, 3, 36)) >undefined : Symbol(undefined) var f2 = function (): null { return null; } ->f2 : Symbol(f2, Decl(transformsElideNullUndefinedType.ts, 7, 3)) +>f2 : Symbol(f2, Decl(transformsElideNullUndefinedType.ts, 6, 3)) var f3 = function (): undefined { return undefined; } ->f3 : Symbol(f3, Decl(transformsElideNullUndefinedType.ts, 8, 3)) +>f3 : Symbol(f3, Decl(transformsElideNullUndefinedType.ts, 7, 3)) >undefined : Symbol(undefined) var f4 = (): null => null; ->f4 : Symbol(f4, Decl(transformsElideNullUndefinedType.ts, 10, 3)) +>f4 : Symbol(f4, Decl(transformsElideNullUndefinedType.ts, 9, 3)) var f5 = (): undefined => undefined; ->f5 : Symbol(f5, Decl(transformsElideNullUndefinedType.ts, 11, 3)) +>f5 : Symbol(f5, Decl(transformsElideNullUndefinedType.ts, 10, 3)) >undefined : Symbol(undefined) function f6(p0: null) { } ->f6 : Symbol(f6, Decl(transformsElideNullUndefinedType.ts, 11, 36)) ->p0 : Symbol(p0, Decl(transformsElideNullUndefinedType.ts, 13, 12)) +>f6 : Symbol(f6, Decl(transformsElideNullUndefinedType.ts, 10, 36)) +>p0 : Symbol(p0, Decl(transformsElideNullUndefinedType.ts, 12, 12)) function f7(p1: undefined) { } ->f7 : Symbol(f7, Decl(transformsElideNullUndefinedType.ts, 13, 25)) ->p1 : Symbol(p1, Decl(transformsElideNullUndefinedType.ts, 14, 12)) +>f7 : Symbol(f7, Decl(transformsElideNullUndefinedType.ts, 12, 25)) +>p1 : Symbol(p1, Decl(transformsElideNullUndefinedType.ts, 13, 12)) var f8 = function (p2: null) { } ->f8 : Symbol(f8, Decl(transformsElideNullUndefinedType.ts, 16, 3)) ->p2 : Symbol(p2, Decl(transformsElideNullUndefinedType.ts, 16, 19)) +>f8 : Symbol(f8, Decl(transformsElideNullUndefinedType.ts, 15, 3)) +>p2 : Symbol(p2, Decl(transformsElideNullUndefinedType.ts, 15, 19)) var f9 = function (p3: undefined) { } ->f9 : Symbol(f9, Decl(transformsElideNullUndefinedType.ts, 17, 3)) ->p3 : Symbol(p3, Decl(transformsElideNullUndefinedType.ts, 17, 19)) +>f9 : Symbol(f9, Decl(transformsElideNullUndefinedType.ts, 16, 3)) +>p3 : Symbol(p3, Decl(transformsElideNullUndefinedType.ts, 16, 19)) var f10 = (p4: null) => { } ->f10 : Symbol(f10, Decl(transformsElideNullUndefinedType.ts, 19, 3)) ->p4 : Symbol(p4, Decl(transformsElideNullUndefinedType.ts, 19, 11)) +>f10 : Symbol(f10, Decl(transformsElideNullUndefinedType.ts, 18, 3)) +>p4 : Symbol(p4, Decl(transformsElideNullUndefinedType.ts, 18, 11)) var f11 = (p5: undefined) => { } ->f11 : Symbol(f11, Decl(transformsElideNullUndefinedType.ts, 20, 3)) ->p5 : Symbol(p5, Decl(transformsElideNullUndefinedType.ts, 20, 11)) +>f11 : Symbol(f11, Decl(transformsElideNullUndefinedType.ts, 19, 3)) +>p5 : Symbol(p5, Decl(transformsElideNullUndefinedType.ts, 19, 11)) class C1 { ->C1 : Symbol(C1, Decl(transformsElideNullUndefinedType.ts, 20, 32)) +>C1 : Symbol(C1, Decl(transformsElideNullUndefinedType.ts, 19, 32)) m0(): null { return null; } ->m0 : Symbol(C1.m0, Decl(transformsElideNullUndefinedType.ts, 22, 10)) +>m0 : Symbol(C1.m0, Decl(transformsElideNullUndefinedType.ts, 21, 10)) m1(): undefined { return undefined; } ->m1 : Symbol(C1.m1, Decl(transformsElideNullUndefinedType.ts, 23, 31)) +>m1 : Symbol(C1.m1, Decl(transformsElideNullUndefinedType.ts, 22, 31)) >undefined : Symbol(undefined) m3(p6: null) { } ->m3 : Symbol(C1.m3, Decl(transformsElideNullUndefinedType.ts, 24, 41)) ->p6 : Symbol(p6, Decl(transformsElideNullUndefinedType.ts, 26, 7)) +>m3 : Symbol(C1.m3, Decl(transformsElideNullUndefinedType.ts, 23, 41)) +>p6 : Symbol(p6, Decl(transformsElideNullUndefinedType.ts, 25, 7)) m4(p7: undefined) { } ->m4 : Symbol(C1.m4, Decl(transformsElideNullUndefinedType.ts, 26, 20)) ->p7 : Symbol(p7, Decl(transformsElideNullUndefinedType.ts, 27, 7)) +>m4 : Symbol(C1.m4, Decl(transformsElideNullUndefinedType.ts, 25, 20)) +>p7 : Symbol(p7, Decl(transformsElideNullUndefinedType.ts, 26, 7)) get a0(): null { return null; } ->a0 : Symbol(C1.a0, Decl(transformsElideNullUndefinedType.ts, 27, 25)) +>a0 : Symbol(C1.a0, Decl(transformsElideNullUndefinedType.ts, 26, 25)) get a1(): undefined { return undefined; } ->a1 : Symbol(C1.a1, Decl(transformsElideNullUndefinedType.ts, 29, 35)) +>a1 : Symbol(C1.a1, Decl(transformsElideNullUndefinedType.ts, 28, 35)) >undefined : Symbol(undefined) set a2(p8: null) { } ->a2 : Symbol(C1.a2, Decl(transformsElideNullUndefinedType.ts, 30, 45)) ->p8 : Symbol(p8, Decl(transformsElideNullUndefinedType.ts, 32, 11)) +>a2 : Symbol(C1.a2, Decl(transformsElideNullUndefinedType.ts, 29, 45)) +>p8 : Symbol(p8, Decl(transformsElideNullUndefinedType.ts, 31, 11)) set a3(p9: undefined) { } ->a3 : Symbol(C1.a3, Decl(transformsElideNullUndefinedType.ts, 32, 24)) ->p9 : Symbol(p9, Decl(transformsElideNullUndefinedType.ts, 33, 11)) +>a3 : Symbol(C1.a3, Decl(transformsElideNullUndefinedType.ts, 31, 24)) +>p9 : Symbol(p9, Decl(transformsElideNullUndefinedType.ts, 32, 11)) } class C2 { constructor(p10: null) { } } ->C2 : Symbol(C2, Decl(transformsElideNullUndefinedType.ts, 34, 1)) ->p10 : Symbol(p10, Decl(transformsElideNullUndefinedType.ts, 36, 23)) +>C2 : Symbol(C2, Decl(transformsElideNullUndefinedType.ts, 33, 1)) +>p10 : Symbol(p10, Decl(transformsElideNullUndefinedType.ts, 35, 23)) class C3 { constructor(p11: undefined) { } } ->C3 : Symbol(C3, Decl(transformsElideNullUndefinedType.ts, 36, 39)) ->p11 : Symbol(p11, Decl(transformsElideNullUndefinedType.ts, 37, 23)) +>C3 : Symbol(C3, Decl(transformsElideNullUndefinedType.ts, 35, 39)) +>p11 : Symbol(p11, Decl(transformsElideNullUndefinedType.ts, 36, 23)) class C4 { ->C4 : Symbol(C4, Decl(transformsElideNullUndefinedType.ts, 37, 44)) +>C4 : Symbol(C4, Decl(transformsElideNullUndefinedType.ts, 36, 44)) f1; ->f1 : Symbol(C4.f1, Decl(transformsElideNullUndefinedType.ts, 39, 10)) +>f1 : Symbol(C4.f1, Decl(transformsElideNullUndefinedType.ts, 38, 10)) constructor(p12: null) { } ->p12 : Symbol(p12, Decl(transformsElideNullUndefinedType.ts, 41, 16)) +>p12 : Symbol(p12, Decl(transformsElideNullUndefinedType.ts, 40, 16)) } class C5 { ->C5 : Symbol(C5, Decl(transformsElideNullUndefinedType.ts, 42, 1)) +>C5 : Symbol(C5, Decl(transformsElideNullUndefinedType.ts, 41, 1)) f2; ->f2 : Symbol(C5.f2, Decl(transformsElideNullUndefinedType.ts, 44, 10)) +>f2 : Symbol(C5.f2, Decl(transformsElideNullUndefinedType.ts, 43, 10)) constructor(p13: undefined) { } ->p13 : Symbol(p13, Decl(transformsElideNullUndefinedType.ts, 46, 16)) +>p13 : Symbol(p13, Decl(transformsElideNullUndefinedType.ts, 45, 16)) } var C6 = class { constructor(p12: null) { } } ->C6 : Symbol(C6, Decl(transformsElideNullUndefinedType.ts, 49, 3)) ->p12 : Symbol(p12, Decl(transformsElideNullUndefinedType.ts, 49, 29)) +>C6 : Symbol(C6, Decl(transformsElideNullUndefinedType.ts, 48, 3)) +>p12 : Symbol(p12, Decl(transformsElideNullUndefinedType.ts, 48, 29)) var C7 = class { constructor(p13: undefined) { } } ->C7 : Symbol(C7, Decl(transformsElideNullUndefinedType.ts, 50, 3)) ->p13 : Symbol(p13, Decl(transformsElideNullUndefinedType.ts, 50, 29)) +>C7 : Symbol(C7, Decl(transformsElideNullUndefinedType.ts, 49, 3)) +>p13 : Symbol(p13, Decl(transformsElideNullUndefinedType.ts, 49, 29)) declare function fn(); ->fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 50, 50)) ->T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 52, 20)) +>fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 49, 50)) +>T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 51, 20)) fn(); ->fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 50, 50)) +>fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 49, 50)) fn(); ->fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 50, 50)) +>fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 49, 50)) declare class D {} ->D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 54, 16)) ->T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 56, 16)) +>D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 53, 16)) +>T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 55, 16)) new D(); ->D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 54, 16)) +>D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 53, 16)) new D(); ->D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 54, 16)) +>D : Symbol(D, Decl(transformsElideNullUndefinedType.ts, 53, 16)) diff --git a/tests/baselines/reference/transformsElideNullUndefinedType.types b/tests/baselines/reference/transformsElideNullUndefinedType.types index ffc26ddaa604e..825f5fc95f81a 100644 --- a/tests/baselines/reference/transformsElideNullUndefinedType.types +++ b/tests/baselines/reference/transformsElideNullUndefinedType.types @@ -1,5 +1,4 @@ === tests/cases/compiler/transformsElideNullUndefinedType.ts === - var v0: null; >v0 : null >null : null diff --git a/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json b/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json index 5918c273ce5bf..97f59dea8eae6 100644 --- a/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json +++ b/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json @@ -5,6 +5,7 @@ "module": "commonjs", /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */ // "lib": [], /* Specify library files to be included in the compilation: */ // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */ // "declaration": true, /* Generates corresponding '.d.ts' file. */ // "sourceMap": true, /* Generates corresponding '.map' file. */ diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json index 38c4542b40739..b90e3fc6c580e 100644 --- a/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json +++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json @@ -5,6 +5,7 @@ "module": "commonjs", /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */ // "lib": [], /* Specify library files to be included in the compilation: */ // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */ // "declaration": true, /* Generates corresponding '.d.ts' file. */ // "sourceMap": true, /* Generates corresponding '.map' file. */ diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json index d948b648153e7..482cfa6a9d550 100644 --- a/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json +++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json @@ -5,6 +5,7 @@ "module": "commonjs", /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */ // "lib": [], /* Specify library files to be included in the compilation: */ // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ "jsx": "react", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */ // "declaration": true, /* Generates corresponding '.d.ts' file. */ // "sourceMap": true, /* Generates corresponding '.map' file. */ diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json index 70870f296e100..c6a26629dab29 100644 --- a/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json +++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json @@ -5,6 +5,7 @@ "module": "commonjs", /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */ // "lib": [], /* Specify library files to be included in the compilation: */ // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */ // "declaration": true, /* Generates corresponding '.d.ts' file. */ // "sourceMap": true, /* Generates corresponding '.map' file. */ diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json index 3eabb0894f163..72289dd1787e0 100644 --- a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json +++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json @@ -5,6 +5,7 @@ "module": "commonjs", /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */ "lib": ["es5","es2015.promise"], /* Specify library files to be included in the compilation: */ // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */ // "declaration": true, /* Generates corresponding '.d.ts' file. */ // "sourceMap": true, /* Generates corresponding '.map' file. */ diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json index 5918c273ce5bf..97f59dea8eae6 100644 --- a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json +++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json @@ -5,6 +5,7 @@ "module": "commonjs", /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */ // "lib": [], /* Specify library files to be included in the compilation: */ // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */ // "declaration": true, /* Generates corresponding '.d.ts' file. */ // "sourceMap": true, /* Generates corresponding '.map' file. */ diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json index b88ac604c14e8..1ac7c8c54da43 100644 --- a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json +++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json @@ -5,6 +5,7 @@ "module": "commonjs", /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */ "lib": ["es5","es2015.core"], /* Specify library files to be included in the compilation: */ // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */ // "declaration": true, /* Generates corresponding '.d.ts' file. */ // "sourceMap": true, /* Generates corresponding '.map' file. */ diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json index db838e21d2fee..33a9ecc5cd408 100644 --- a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json +++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json @@ -5,6 +5,7 @@ "module": "commonjs", /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */ // "lib": [], /* Specify library files to be included in the compilation: */ // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */ // "declaration": true, /* Generates corresponding '.d.ts' file. */ // "sourceMap": true, /* Generates corresponding '.map' file. */ diff --git a/tests/baselines/reference/tsxAttributeErrors.errors.txt b/tests/baselines/reference/tsxAttributeErrors.errors.txt index 50dfd88c52702..cd515e40d76b8 100644 --- a/tests/baselines/reference/tsxAttributeErrors.errors.txt +++ b/tests/baselines/reference/tsxAttributeErrors.errors.txt @@ -1,16 +1,15 @@ -tests/cases/conformance/jsx/tsxAttributeErrors.tsx(15,6): error TS2322: Type '{ text: 42; }' is not assignable to type '{ text?: string; width?: number; }'. +tests/cases/conformance/jsx/tsxAttributeErrors.tsx(14,6): error TS2322: Type '{ text: 42; }' is not assignable to type '{ text?: string; width?: number; }'. Types of property 'text' are incompatible. Type '42' is not assignable to type 'string'. -tests/cases/conformance/jsx/tsxAttributeErrors.tsx(18,6): error TS2322: Type '{ width: "foo"; }' is not assignable to type '{ text?: string; width?: number; }'. +tests/cases/conformance/jsx/tsxAttributeErrors.tsx(17,6): error TS2322: Type '{ width: "foo"; }' is not assignable to type '{ text?: string; width?: number; }'. Types of property 'width' are incompatible. Type '"foo"' is not assignable to type 'number'. -tests/cases/conformance/jsx/tsxAttributeErrors.tsx(22,6): error TS2322: Type '{ text: number; }' is not assignable to type '{ text?: string; width?: number; }'. +tests/cases/conformance/jsx/tsxAttributeErrors.tsx(21,6): error TS2322: Type '{ text: number; }' is not assignable to type '{ text?: string; width?: number; }'. Types of property 'text' are incompatible. Type 'number' is not assignable to type 'string'. ==== tests/cases/conformance/jsx/tsxAttributeErrors.tsx (3 errors) ==== - declare namespace JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeErrors.js b/tests/baselines/reference/tsxAttributeErrors.js index 2ab862e0efec9..374418c2525e9 100644 --- a/tests/baselines/reference/tsxAttributeErrors.js +++ b/tests/baselines/reference/tsxAttributeErrors.js @@ -1,5 +1,4 @@ //// [tsxAttributeErrors.tsx] - declare namespace JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution.js b/tests/baselines/reference/tsxAttributeResolution.js index ed3915b7ff2b1..73c47a440b765 100644 --- a/tests/baselines/reference/tsxAttributeResolution.js +++ b/tests/baselines/reference/tsxAttributeResolution.js @@ -1,5 +1,4 @@ //// [tsxAttributeResolution.tsx] - declare namespace JSX { interface IntrinsicElements { x: { y: number; z: string; }; diff --git a/tests/baselines/reference/tsxAttributeResolution.symbols b/tests/baselines/reference/tsxAttributeResolution.symbols index bb0c5e7878fcd..78dbaa0bd11fd 100644 --- a/tests/baselines/reference/tsxAttributeResolution.symbols +++ b/tests/baselines/reference/tsxAttributeResolution.symbols @@ -1,15 +1,14 @@ === tests/cases/conformance/jsx/tsxAttributeResolution.tsx === - declare namespace JSX { >JSX : Symbol(JSX, Decl(tsxAttributeResolution.tsx, 0, 0)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxAttributeResolution.tsx, 1, 23)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxAttributeResolution.tsx, 0, 23)) x: { y: number; z: string; }; ->x : Symbol(IntrinsicElements.x, Decl(tsxAttributeResolution.tsx, 2, 30)) ->y : Symbol(y, Decl(tsxAttributeResolution.tsx, 3, 6)) ->z : Symbol(z, Decl(tsxAttributeResolution.tsx, 3, 17)) +>x : Symbol(IntrinsicElements.x, Decl(tsxAttributeResolution.tsx, 1, 30)) +>y : Symbol(y, Decl(tsxAttributeResolution.tsx, 2, 6)) +>z : Symbol(z, Decl(tsxAttributeResolution.tsx, 2, 17)) } } diff --git a/tests/baselines/reference/tsxAttributeResolution.types b/tests/baselines/reference/tsxAttributeResolution.types index f0adc582944b2..ef5a9506bd781 100644 --- a/tests/baselines/reference/tsxAttributeResolution.types +++ b/tests/baselines/reference/tsxAttributeResolution.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxAttributeResolution.tsx === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/tsxAttributeResolution10.errors.txt b/tests/baselines/reference/tsxAttributeResolution10.errors.txt index dce068dbb769d..3710b583e9b5b 100644 --- a/tests/baselines/reference/tsxAttributeResolution10.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution10.errors.txt @@ -4,7 +4,6 @@ tests/cases/conformance/jsx/file.tsx(11,14): error TS2322: Type '{ bar: "world"; ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution10.js b/tests/baselines/reference/tsxAttributeResolution10.js index 235cca0be1c98..141743c17bc20 100644 --- a/tests/baselines/reference/tsxAttributeResolution10.js +++ b/tests/baselines/reference/tsxAttributeResolution10.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution10.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution11.errors.txt b/tests/baselines/reference/tsxAttributeResolution11.errors.txt index a46bf4ba16fe0..08a75c3b8bb87 100644 --- a/tests/baselines/reference/tsxAttributeResolution11.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution11.errors.txt @@ -3,7 +3,6 @@ tests/cases/conformance/jsx/file.tsx(11,22): error TS2322: Type '{ bar: "world"; ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution11.js b/tests/baselines/reference/tsxAttributeResolution11.js index 03b843c209aad..c4d62a7147aa3 100644 --- a/tests/baselines/reference/tsxAttributeResolution11.js +++ b/tests/baselines/reference/tsxAttributeResolution11.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution11.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution12.errors.txt b/tests/baselines/reference/tsxAttributeResolution12.errors.txt index 041776814ca93..3113eb833ba2b 100644 --- a/tests/baselines/reference/tsxAttributeResolution12.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution12.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/jsx/file.tsx(26,10): error TS2322: Type '{}' is not assignable to type 'IntrinsicAttributes & { reqd: any; }'. +tests/cases/conformance/jsx/file.tsx(25,10): error TS2322: Type '{}' is not assignable to type 'IntrinsicAttributes & { reqd: any; }'. Type '{}' is not assignable to type '{ reqd: any; }'. Property 'reqd' is missing in type '{}'. -tests/cases/conformance/jsx/file.tsx(29,10): error TS2322: Type '{}' is not assignable to type 'IntrinsicAttributes & { reqd: any; }'. +tests/cases/conformance/jsx/file.tsx(28,10): error TS2322: Type '{}' is not assignable to type 'IntrinsicAttributes & { reqd: any; }'. Type '{}' is not assignable to type '{ reqd: any; }'. Property 'reqd' is missing in type '{}'. ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { @@ -21,7 +20,6 @@ tests/cases/conformance/jsx/file.tsx(29,10): error TS2322: Type '{}' is not assi } ==== tests/cases/conformance/jsx/file.tsx (2 errors) ==== - declare class Component { constructor(props?: P, context?: any); setState(f: (prevState: S, props: P) => S, callback?: () => any): void; diff --git a/tests/baselines/reference/tsxAttributeResolution12.js b/tests/baselines/reference/tsxAttributeResolution12.js index 05a854a7cbc07..7e64848587459 100644 --- a/tests/baselines/reference/tsxAttributeResolution12.js +++ b/tests/baselines/reference/tsxAttributeResolution12.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution12.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { @@ -15,7 +14,6 @@ declare module JSX { } //// [file.tsx] - declare class Component { constructor(props?: P, context?: any); setState(f: (prevState: S, props: P) => S, callback?: () => any): void; diff --git a/tests/baselines/reference/tsxAttributeResolution13.js b/tests/baselines/reference/tsxAttributeResolution13.js index e6c942eb926c2..475bbd2d6e279 100644 --- a/tests/baselines/reference/tsxAttributeResolution13.js +++ b/tests/baselines/reference/tsxAttributeResolution13.js @@ -1,5 +1,4 @@ //// [test.tsx] - function Test() { } diff --git a/tests/baselines/reference/tsxAttributeResolution13.symbols b/tests/baselines/reference/tsxAttributeResolution13.symbols index a913e50969cc5..641d7886c7b45 100644 --- a/tests/baselines/reference/tsxAttributeResolution13.symbols +++ b/tests/baselines/reference/tsxAttributeResolution13.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/test.tsx === - function Test() { } >Test : Symbol(Test, Decl(test.tsx, 0, 0)) diff --git a/tests/baselines/reference/tsxAttributeResolution13.types b/tests/baselines/reference/tsxAttributeResolution13.types index 1a426d86e7d98..c523c8a40d042 100644 --- a/tests/baselines/reference/tsxAttributeResolution13.types +++ b/tests/baselines/reference/tsxAttributeResolution13.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/test.tsx === - function Test() { } >Test : () => void diff --git a/tests/baselines/reference/tsxAttributeResolution14.errors.txt b/tests/baselines/reference/tsxAttributeResolution14.errors.txt index 79b4a55f10245..ada85a7a9101d 100644 --- a/tests/baselines/reference/tsxAttributeResolution14.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution14.errors.txt @@ -1,13 +1,12 @@ -tests/cases/conformance/jsx/file.tsx(14,28): error TS2322: Type '{ primaryText: 2; }' is not assignable to type 'IProps'. +tests/cases/conformance/jsx/file.tsx(13,28): error TS2322: Type '{ primaryText: 2; }' is not assignable to type 'IProps'. Types of property 'primaryText' are incompatible. Type '2' is not assignable to type 'string'. -tests/cases/conformance/jsx/file.tsx(16,28): error TS2322: Type '{ justRandomProp1: true; primaryText: "hello"; }' is not assignable to type 'IProps'. +tests/cases/conformance/jsx/file.tsx(15,28): error TS2322: Type '{ justRandomProp1: true; primaryText: "hello"; }' is not assignable to type 'IProps'. Property 'justRandomProp1' is incompatible with index signature. Type 'true' is not assignable to type 'string | number'. ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { @@ -17,7 +16,6 @@ tests/cases/conformance/jsx/file.tsx(16,28): error TS2322: Type '{ justRandomPro } ==== tests/cases/conformance/jsx/file.tsx (2 errors) ==== - interface IProps { primaryText: string, [propName: string]: string | number diff --git a/tests/baselines/reference/tsxAttributeResolution14.js b/tests/baselines/reference/tsxAttributeResolution14.js index d920179458cc0..26633239d3918 100644 --- a/tests/baselines/reference/tsxAttributeResolution14.js +++ b/tests/baselines/reference/tsxAttributeResolution14.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution14.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { @@ -11,7 +10,6 @@ declare module JSX { } //// [file.tsx] - interface IProps { primaryText: string, [propName: string]: string | number diff --git a/tests/baselines/reference/tsxAttributeResolution15.errors.txt b/tests/baselines/reference/tsxAttributeResolution15.errors.txt index e4d2b6f89a5aa..870599acd2770 100644 --- a/tests/baselines/reference/tsxAttributeResolution15.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution15.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/jsx/file.tsx(12,21): error TS2322: Type '{ prop1: "hello"; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & {} & { children?: ReactNode; }'. - Property 'prop1' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes & {} & { children?: ReactNode; }'. +tests/cases/conformance/jsx/file.tsx(11,21): error TS2322: Type '{ prop1: "hello"; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & { children?: ReactNode; }'. + Property 'prop1' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes & { children?: ReactNode; }'. ==== tests/cases/conformance/jsx/file.tsx (1 errors) ==== - import React = require('react'); class BigGreeter extends React.Component<{ }, {}> { @@ -16,8 +15,8 @@ tests/cases/conformance/jsx/file.tsx(12,21): error TS2322: Type '{ prop1: "hello // Error let a = ~~~~~~~~~~~~~ -!!! error TS2322: Type '{ prop1: "hello"; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & {} & { children?: ReactNode; }'. -!!! error TS2322: Property 'prop1' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes & {} & { children?: ReactNode; }'. +!!! error TS2322: Type '{ prop1: "hello"; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & { children?: ReactNode; }'. +!!! error TS2322: Property 'prop1' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes & { children?: ReactNode; }'. // OK let b = { this.textInput = input; }} /> diff --git a/tests/baselines/reference/tsxAttributeResolution15.js b/tests/baselines/reference/tsxAttributeResolution15.js index 110c33593c650..0fbc01e6e0fce 100644 --- a/tests/baselines/reference/tsxAttributeResolution15.js +++ b/tests/baselines/reference/tsxAttributeResolution15.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); class BigGreeter extends React.Component<{ }, {}> { diff --git a/tests/baselines/reference/tsxAttributeResolution16.js b/tests/baselines/reference/tsxAttributeResolution16.js index 1182c886b94b0..1c05446b4938e 100644 --- a/tests/baselines/reference/tsxAttributeResolution16.js +++ b/tests/baselines/reference/tsxAttributeResolution16.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); interface Address { diff --git a/tests/baselines/reference/tsxAttributeResolution16.symbols b/tests/baselines/reference/tsxAttributeResolution16.symbols index 0c271566de996..d2ae05714ef6a 100644 --- a/tests/baselines/reference/tsxAttributeResolution16.symbols +++ b/tests/baselines/reference/tsxAttributeResolution16.symbols @@ -1,57 +1,56 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : Symbol(React, Decl(file.tsx, 0, 0)) interface Address { ->Address : Symbol(Address, Decl(file.tsx, 1, 32)) +>Address : Symbol(Address, Decl(file.tsx, 0, 32)) street: string; ->street : Symbol(Address.street, Decl(file.tsx, 3, 19)) +>street : Symbol(Address.street, Decl(file.tsx, 2, 19)) country: string; ->country : Symbol(Address.country, Decl(file.tsx, 4, 17)) +>country : Symbol(Address.country, Decl(file.tsx, 3, 17)) } interface CanadianAddress extends Address { ->CanadianAddress : Symbol(CanadianAddress, Decl(file.tsx, 6, 1)) ->Address : Symbol(Address, Decl(file.tsx, 1, 32)) +>CanadianAddress : Symbol(CanadianAddress, Decl(file.tsx, 5, 1)) +>Address : Symbol(Address, Decl(file.tsx, 0, 32)) postalCode: string; ->postalCode : Symbol(CanadianAddress.postalCode, Decl(file.tsx, 8, 43)) +>postalCode : Symbol(CanadianAddress.postalCode, Decl(file.tsx, 7, 43)) } interface AmericanAddress extends Address { ->AmericanAddress : Symbol(AmericanAddress, Decl(file.tsx, 10, 1)) ->Address : Symbol(Address, Decl(file.tsx, 1, 32)) +>AmericanAddress : Symbol(AmericanAddress, Decl(file.tsx, 9, 1)) +>Address : Symbol(Address, Decl(file.tsx, 0, 32)) zipCode: string; ->zipCode : Symbol(AmericanAddress.zipCode, Decl(file.tsx, 12, 43)) +>zipCode : Symbol(AmericanAddress.zipCode, Decl(file.tsx, 11, 43)) } type Properties = CanadianAddress | AmericanAddress; ->Properties : Symbol(Properties, Decl(file.tsx, 14, 1)) ->CanadianAddress : Symbol(CanadianAddress, Decl(file.tsx, 6, 1)) ->AmericanAddress : Symbol(AmericanAddress, Decl(file.tsx, 10, 1)) +>Properties : Symbol(Properties, Decl(file.tsx, 13, 1)) +>CanadianAddress : Symbol(CanadianAddress, Decl(file.tsx, 5, 1)) +>AmericanAddress : Symbol(AmericanAddress, Decl(file.tsx, 9, 1)) export class AddressComp extends React.Component { ->AddressComp : Symbol(AddressComp, Decl(file.tsx, 16, 52)) +>AddressComp : Symbol(AddressComp, Decl(file.tsx, 15, 52)) >React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) >React : Symbol(React, Decl(file.tsx, 0, 0)) >Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) ->Properties : Symbol(Properties, Decl(file.tsx, 14, 1)) +>Properties : Symbol(Properties, Decl(file.tsx, 13, 1)) public render() { ->render : Symbol(AddressComp.render, Decl(file.tsx, 18, 68)) +>render : Symbol(AddressComp.render, Decl(file.tsx, 17, 68)) return null; } } let a = ->a : Symbol(a, Decl(file.tsx, 24, 3)) ->AddressComp : Symbol(AddressComp, Decl(file.tsx, 16, 52)) ->postalCode : Symbol(postalCode, Decl(file.tsx, 24, 20)) ->street : Symbol(street, Decl(file.tsx, 24, 41)) ->country : Symbol(country, Decl(file.tsx, 24, 60)) +>a : Symbol(a, Decl(file.tsx, 23, 3)) +>AddressComp : Symbol(AddressComp, Decl(file.tsx, 15, 52)) +>postalCode : Symbol(postalCode, Decl(file.tsx, 23, 20)) +>street : Symbol(street, Decl(file.tsx, 23, 41)) +>country : Symbol(country, Decl(file.tsx, 23, 60)) diff --git a/tests/baselines/reference/tsxAttributeResolution16.types b/tests/baselines/reference/tsxAttributeResolution16.types index 68134d7ac2d31..c7f13ca509691 100644 --- a/tests/baselines/reference/tsxAttributeResolution16.types +++ b/tests/baselines/reference/tsxAttributeResolution16.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : typeof React diff --git a/tests/baselines/reference/tsxAttributeResolution9.errors.txt b/tests/baselines/reference/tsxAttributeResolution9.errors.txt index 670cdd6dfcb47..130fe6faab602 100644 --- a/tests/baselines/reference/tsxAttributeResolution9.errors.txt +++ b/tests/baselines/reference/tsxAttributeResolution9.errors.txt @@ -4,7 +4,6 @@ tests/cases/conformance/jsx/file.tsx(9,14): error TS2322: Type '{ foo: 0; }' is ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxAttributeResolution9.js b/tests/baselines/reference/tsxAttributeResolution9.js index d7880c820d86d..a982fea412b1e 100644 --- a/tests/baselines/reference/tsxAttributeResolution9.js +++ b/tests/baselines/reference/tsxAttributeResolution9.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxAttributeResolution9.tsx] //// //// [react.d.ts] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution1.js b/tests/baselines/reference/tsxDefaultAttributesResolution1.js index 87c079901d9ec..8d22db3b69f13 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution1.js +++ b/tests/baselines/reference/tsxDefaultAttributesResolution1.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); interface Prop { diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols b/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols index a0efe4f9dbe31..900aa7cf84225 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols +++ b/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols @@ -1,23 +1,22 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : Symbol(React, Decl(file.tsx, 0, 0)) interface Prop { ->Prop : Symbol(Prop, Decl(file.tsx, 1, 32)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) x: boolean; ->x : Symbol(Prop.x, Decl(file.tsx, 3, 16)) +>x : Symbol(Prop.x, Decl(file.tsx, 2, 16)) } class Poisoned extends React.Component { ->Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1)) +>Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1)) >React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) >React : Symbol(React, Decl(file.tsx, 0, 0)) >Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) ->Prop : Symbol(Prop, Decl(file.tsx, 1, 32)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) render() { ->render : Symbol(Poisoned.render, Decl(file.tsx, 6, 50)) +>render : Symbol(Poisoned.render, Decl(file.tsx, 5, 50)) return

Hello
; >div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2397, 45)) @@ -27,7 +26,7 @@ class Poisoned extends React.Component { // OK let p = ; ->p : Symbol(p, Decl(file.tsx, 13, 3)) ->Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1)) ->x : Symbol(x, Decl(file.tsx, 13, 17)) +>p : Symbol(p, Decl(file.tsx, 12, 3)) +>Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1)) +>x : Symbol(x, Decl(file.tsx, 12, 17)) diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution1.types b/tests/baselines/reference/tsxDefaultAttributesResolution1.types index 1734380a55dde..3167e1bd7ac35 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution1.types +++ b/tests/baselines/reference/tsxDefaultAttributesResolution1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : typeof React diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution2.js b/tests/baselines/reference/tsxDefaultAttributesResolution2.js index bc5e6a94ef20b..38735169f10a3 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution2.js +++ b/tests/baselines/reference/tsxDefaultAttributesResolution2.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); interface Prop { diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols b/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols index 7bcdc7ccfa20d..766505b551812 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols +++ b/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols @@ -1,23 +1,22 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : Symbol(React, Decl(file.tsx, 0, 0)) interface Prop { ->Prop : Symbol(Prop, Decl(file.tsx, 1, 32)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) x: true; ->x : Symbol(Prop.x, Decl(file.tsx, 3, 16)) +>x : Symbol(Prop.x, Decl(file.tsx, 2, 16)) } class Poisoned extends React.Component { ->Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1)) +>Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1)) >React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) >React : Symbol(React, Decl(file.tsx, 0, 0)) >Component : Symbol(React.Component, Decl(react.d.ts, 158, 55)) ->Prop : Symbol(Prop, Decl(file.tsx, 1, 32)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) render() { ->render : Symbol(Poisoned.render, Decl(file.tsx, 6, 50)) +>render : Symbol(Poisoned.render, Decl(file.tsx, 5, 50)) return
Hello
; >div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2397, 45)) @@ -27,7 +26,7 @@ class Poisoned extends React.Component { // OK let p = ; ->p : Symbol(p, Decl(file.tsx, 13, 3)) ->Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1)) ->x : Symbol(x, Decl(file.tsx, 13, 17)) +>p : Symbol(p, Decl(file.tsx, 12, 3)) +>Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1)) +>x : Symbol(x, Decl(file.tsx, 12, 17)) diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution2.types b/tests/baselines/reference/tsxDefaultAttributesResolution2.types index ab2bc0c7da6e4..4b6ceaf0e15db 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution2.types +++ b/tests/baselines/reference/tsxDefaultAttributesResolution2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - import React = require('react'); >React : typeof React diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution3.errors.txt b/tests/baselines/reference/tsxDefaultAttributesResolution3.errors.txt index bfb780d202407..cb946258827dd 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution3.errors.txt +++ b/tests/baselines/reference/tsxDefaultAttributesResolution3.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/jsx/file.tsx(14,19): error TS2322: Type '{ x: true; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & Prop & { children?: ReactNode; }'. +tests/cases/conformance/jsx/file.tsx(13,19): error TS2322: Type '{ x: true; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes & Prop & { children?: ReactNode; }'. Type '{ x: true; }' is not assignable to type 'Prop'. Types of property 'x' are incompatible. Type 'true' is not assignable to type 'false'. ==== tests/cases/conformance/jsx/file.tsx (1 errors) ==== - import React = require('react'); interface Prop { diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution3.js b/tests/baselines/reference/tsxDefaultAttributesResolution3.js index 82d940ff580cc..14da51516b578 100644 --- a/tests/baselines/reference/tsxDefaultAttributesResolution3.js +++ b/tests/baselines/reference/tsxDefaultAttributesResolution3.js @@ -1,5 +1,4 @@ //// [file.tsx] - import React = require('react'); interface Prop { diff --git a/tests/baselines/reference/tsxDefaultImports.js b/tests/baselines/reference/tsxDefaultImports.js index c918efb5f4fb5..a6c1a4217a3ac 100644 --- a/tests/baselines/reference/tsxDefaultImports.js +++ b/tests/baselines/reference/tsxDefaultImports.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/tsxDefaultImports.ts] //// //// [a.ts] - enum SomeEnum { one, } diff --git a/tests/baselines/reference/tsxDefaultImports.symbols b/tests/baselines/reference/tsxDefaultImports.symbols index e42392e24aafb..2c47e1e30f397 100644 --- a/tests/baselines/reference/tsxDefaultImports.symbols +++ b/tests/baselines/reference/tsxDefaultImports.symbols @@ -1,16 +1,15 @@ === tests/cases/compiler/a.ts === - enum SomeEnum { >SomeEnum : Symbol(SomeEnum, Decl(a.ts, 0, 0)) one, ->one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15)) +>one : Symbol(SomeEnum.one, Decl(a.ts, 0, 15)) } export default class SomeClass { ->SomeClass : Symbol(SomeClass, Decl(a.ts, 3, 1)) +>SomeClass : Symbol(SomeClass, Decl(a.ts, 2, 1)) public static E = SomeEnum; ->E : Symbol(SomeClass.E, Decl(a.ts, 4, 32)) +>E : Symbol(SomeClass.E, Decl(a.ts, 3, 32)) >SomeEnum : Symbol(SomeEnum, Decl(a.ts, 0, 0)) } @@ -21,9 +20,9 @@ import {default as Def} from "./a" let a = Def.E.one; >a : Symbol(a, Decl(b.ts, 1, 3)) ->Def.E.one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15)) ->Def.E : Symbol(Def.E, Decl(a.ts, 4, 32)) +>Def.E.one : Symbol(SomeEnum.one, Decl(a.ts, 0, 15)) +>Def.E : Symbol(Def.E, Decl(a.ts, 3, 32)) >Def : Symbol(Def, Decl(b.ts, 0, 8)) ->E : Symbol(Def.E, Decl(a.ts, 4, 32)) ->one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15)) +>E : Symbol(Def.E, Decl(a.ts, 3, 32)) +>one : Symbol(SomeEnum.one, Decl(a.ts, 0, 15)) diff --git a/tests/baselines/reference/tsxDefaultImports.types b/tests/baselines/reference/tsxDefaultImports.types index a9bdedf3efd21..08c00256e0ef8 100644 --- a/tests/baselines/reference/tsxDefaultImports.types +++ b/tests/baselines/reference/tsxDefaultImports.types @@ -1,5 +1,4 @@ === tests/cases/compiler/a.ts === - enum SomeEnum { >SomeEnum : SomeEnum diff --git a/tests/baselines/reference/tsxDynamicTagName1.js b/tests/baselines/reference/tsxDynamicTagName1.js index e77d126dd8320..023f6c0cb5c27 100644 --- a/tests/baselines/reference/tsxDynamicTagName1.js +++ b/tests/baselines/reference/tsxDynamicTagName1.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName1.tsx] - var CustomTag = "h1"; Hello World // No error diff --git a/tests/baselines/reference/tsxDynamicTagName1.symbols b/tests/baselines/reference/tsxDynamicTagName1.symbols index c3ba6440e4886..80601b2655b98 100644 --- a/tests/baselines/reference/tsxDynamicTagName1.symbols +++ b/tests/baselines/reference/tsxDynamicTagName1.symbols @@ -1,9 +1,8 @@ === tests/cases/conformance/jsx/tsxDynamicTagName1.tsx === - var CustomTag = "h1"; ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 1, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 0, 3)) Hello World // No error ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 1, 3)) ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 1, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 0, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName1.tsx, 0, 3)) diff --git a/tests/baselines/reference/tsxDynamicTagName1.types b/tests/baselines/reference/tsxDynamicTagName1.types index def9810e05262..716c2569e3b20 100644 --- a/tests/baselines/reference/tsxDynamicTagName1.types +++ b/tests/baselines/reference/tsxDynamicTagName1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxDynamicTagName1.tsx === - var CustomTag = "h1"; >CustomTag : string >"h1" : "h1" diff --git a/tests/baselines/reference/tsxDynamicTagName2.errors.txt b/tests/baselines/reference/tsxDynamicTagName2.errors.txt index 008a013e379ff..3c91cd80f3c39 100644 --- a/tests/baselines/reference/tsxDynamicTagName2.errors.txt +++ b/tests/baselines/reference/tsxDynamicTagName2.errors.txt @@ -1,9 +1,8 @@ -tests/cases/conformance/jsx/tsxDynamicTagName2.tsx(10,1): error TS2339: Property 'customTag' does not exist on type 'JSX.IntrinsicElements'. -tests/cases/conformance/jsx/tsxDynamicTagName2.tsx(10,25): error TS2339: Property 'customTag' does not exist on type 'JSX.IntrinsicElements'. +tests/cases/conformance/jsx/tsxDynamicTagName2.tsx(9,1): error TS2339: Property 'customTag' does not exist on type 'JSX.IntrinsicElements'. +tests/cases/conformance/jsx/tsxDynamicTagName2.tsx(9,25): error TS2339: Property 'customTag' does not exist on type 'JSX.IntrinsicElements'. ==== tests/cases/conformance/jsx/tsxDynamicTagName2.tsx (2 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName2.js b/tests/baselines/reference/tsxDynamicTagName2.js index 7fb7bb1a96563..159a91fceed67 100644 --- a/tests/baselines/reference/tsxDynamicTagName2.js +++ b/tests/baselines/reference/tsxDynamicTagName2.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName2.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName3.errors.txt b/tests/baselines/reference/tsxDynamicTagName3.errors.txt index 40c10c63f53da..406a12bd14f01 100644 --- a/tests/baselines/reference/tsxDynamicTagName3.errors.txt +++ b/tests/baselines/reference/tsxDynamicTagName3.errors.txt @@ -1,8 +1,7 @@ -tests/cases/conformance/jsx/tsxDynamicTagName3.tsx(10,1): error TS2339: Property 'h1' does not exist on type 'JSX.IntrinsicElements'. +tests/cases/conformance/jsx/tsxDynamicTagName3.tsx(9,1): error TS2339: Property 'h1' does not exist on type 'JSX.IntrinsicElements'. ==== tests/cases/conformance/jsx/tsxDynamicTagName3.tsx (1 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName3.js b/tests/baselines/reference/tsxDynamicTagName3.js index 63c2a0a398b17..236dccaf0cd61 100644 --- a/tests/baselines/reference/tsxDynamicTagName3.js +++ b/tests/baselines/reference/tsxDynamicTagName3.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName3.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName4.js b/tests/baselines/reference/tsxDynamicTagName4.js index e708273237ddf..3207df9d54990 100644 --- a/tests/baselines/reference/tsxDynamicTagName4.js +++ b/tests/baselines/reference/tsxDynamicTagName4.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName4.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName4.symbols b/tests/baselines/reference/tsxDynamicTagName4.symbols index 3f0fe57ce1fe9..3074bc754f2c7 100644 --- a/tests/baselines/reference/tsxDynamicTagName4.symbols +++ b/tests/baselines/reference/tsxDynamicTagName4.symbols @@ -1,26 +1,25 @@ === tests/cases/conformance/jsx/tsxDynamicTagName4.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(tsxDynamicTagName4.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(tsxDynamicTagName4.tsx, 1, 20)) +>Element : Symbol(Element, Decl(tsxDynamicTagName4.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxDynamicTagName4.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxDynamicTagName4.tsx, 1, 22)) div: any ->div : Symbol(IntrinsicElements.div, Decl(tsxDynamicTagName4.tsx, 3, 30)) +>div : Symbol(IntrinsicElements.div, Decl(tsxDynamicTagName4.tsx, 2, 30)) h1: any ->h1 : Symbol(IntrinsicElements.h1, Decl(tsxDynamicTagName4.tsx, 4, 10)) +>h1 : Symbol(IntrinsicElements.h1, Decl(tsxDynamicTagName4.tsx, 3, 10)) } } var CustomTag: "h1" = "h1"; ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 9, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 8, 3)) Hello World ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 9, 3)) ->CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 9, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 8, 3)) +>CustomTag : Symbol(CustomTag, Decl(tsxDynamicTagName4.tsx, 8, 3)) diff --git a/tests/baselines/reference/tsxDynamicTagName4.types b/tests/baselines/reference/tsxDynamicTagName4.types index 3a9a34f289832..c857b2ee9f91a 100644 --- a/tests/baselines/reference/tsxDynamicTagName4.types +++ b/tests/baselines/reference/tsxDynamicTagName4.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxDynamicTagName4.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxDynamicTagName5.js b/tests/baselines/reference/tsxDynamicTagName5.js index 4dd03843f155a..1aa3650a9632d 100644 --- a/tests/baselines/reference/tsxDynamicTagName5.js +++ b/tests/baselines/reference/tsxDynamicTagName5.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxDynamicTagName5.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName5.symbols b/tests/baselines/reference/tsxDynamicTagName5.symbols index 9abac5521c9ad..a37ac84b44686 100644 --- a/tests/baselines/reference/tsxDynamicTagName5.symbols +++ b/tests/baselines/reference/tsxDynamicTagName5.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } ->Component : Symbol(Component, Decl(react.d.ts, 1, 24)) ->T : Symbol(T, Decl(react.d.ts, 2, 17)) ->U : Symbol(U, Decl(react.d.ts, 2, 19)) +>Component : Symbol(Component, Decl(react.d.ts, 0, 24)) +>T : Symbol(T, Decl(react.d.ts, 1, 17)) +>U : Symbol(U, Decl(react.d.ts, 1, 19)) } === tests/cases/conformance/jsx/app.tsx === @@ -13,9 +12,9 @@ import * as React from 'react'; export class Text extends React.Component<{}, {}> { >Text : Symbol(Text, Decl(app.tsx, 0, 31)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(app.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) _tagName: string = 'div'; >_tagName : Symbol(Text._tagName, Decl(app.tsx, 2, 51)) diff --git a/tests/baselines/reference/tsxDynamicTagName5.types b/tests/baselines/reference/tsxDynamicTagName5.types index dbc01e894834c..b746be2e88e04 100644 --- a/tests/baselines/reference/tsxDynamicTagName5.types +++ b/tests/baselines/reference/tsxDynamicTagName5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } >Component : Component diff --git a/tests/baselines/reference/tsxDynamicTagName6.js b/tests/baselines/reference/tsxDynamicTagName6.js index a7ec12b50b728..373070393f63e 100644 --- a/tests/baselines/reference/tsxDynamicTagName6.js +++ b/tests/baselines/reference/tsxDynamicTagName6.js @@ -1,5 +1,4 @@ //// [tsxDynamicTagName6.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxDynamicTagName6.symbols b/tests/baselines/reference/tsxDynamicTagName6.symbols index f1afd91eacb99..700deec00a1f0 100644 --- a/tests/baselines/reference/tsxDynamicTagName6.symbols +++ b/tests/baselines/reference/tsxDynamicTagName6.symbols @@ -1,26 +1,25 @@ === tests/cases/conformance/jsx/tsxDynamicTagName6.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(tsxDynamicTagName6.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(tsxDynamicTagName6.tsx, 1, 20)) +>Element : Symbol(Element, Decl(tsxDynamicTagName6.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxDynamicTagName6.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxDynamicTagName6.tsx, 1, 22)) div: any ->div : Symbol(IntrinsicElements.div, Decl(tsxDynamicTagName6.tsx, 3, 30)) +>div : Symbol(IntrinsicElements.div, Decl(tsxDynamicTagName6.tsx, 2, 30)) } } const t = {tag:'h1'} ->t : Symbol(t, Decl(tsxDynamicTagName6.tsx, 8, 5)) ->tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 8, 11)) +>t : Symbol(t, Decl(tsxDynamicTagName6.tsx, 7, 5)) +>tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 7, 11)) const foo = // No error ->foo : Symbol(foo, Decl(tsxDynamicTagName6.tsx, 9, 5)) ->t.tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 8, 11)) ->t : Symbol(t, Decl(tsxDynamicTagName6.tsx, 8, 5)) ->tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 8, 11)) +>foo : Symbol(foo, Decl(tsxDynamicTagName6.tsx, 8, 5)) +>t.tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 7, 11)) +>t : Symbol(t, Decl(tsxDynamicTagName6.tsx, 7, 5)) +>tag : Symbol(tag, Decl(tsxDynamicTagName6.tsx, 7, 11)) diff --git a/tests/baselines/reference/tsxDynamicTagName6.types b/tests/baselines/reference/tsxDynamicTagName6.types index b4fbb1ed358c9..33d75fbca72c2 100644 --- a/tests/baselines/reference/tsxDynamicTagName6.types +++ b/tests/baselines/reference/tsxDynamicTagName6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxDynamicTagName6.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxDynamicTagName7.errors.txt b/tests/baselines/reference/tsxDynamicTagName7.errors.txt index 19f9bed3c27de..3d1ba209c1234 100644 --- a/tests/baselines/reference/tsxDynamicTagName7.errors.txt +++ b/tests/baselines/reference/tsxDynamicTagName7.errors.txt @@ -2,7 +2,6 @@ tests/cases/conformance/jsx/app.tsx(8,8): error TS2604: JSX element type 'this' ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName7.js b/tests/baselines/reference/tsxDynamicTagName7.js index f4f230b995af9..1bfade5d5da29 100644 --- a/tests/baselines/reference/tsxDynamicTagName7.js +++ b/tests/baselines/reference/tsxDynamicTagName7.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxDynamicTagName7.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName8.js b/tests/baselines/reference/tsxDynamicTagName8.js index 348574ebf42e8..34a587c7d19b3 100644 --- a/tests/baselines/reference/tsxDynamicTagName8.js +++ b/tests/baselines/reference/tsxDynamicTagName8.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxDynamicTagName8.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName8.symbols b/tests/baselines/reference/tsxDynamicTagName8.symbols index 87a71e740dee5..996391941a9a7 100644 --- a/tests/baselines/reference/tsxDynamicTagName8.symbols +++ b/tests/baselines/reference/tsxDynamicTagName8.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } ->Component : Symbol(Component, Decl(react.d.ts, 1, 24)) ->T : Symbol(T, Decl(react.d.ts, 2, 17)) ->U : Symbol(U, Decl(react.d.ts, 2, 19)) +>Component : Symbol(Component, Decl(react.d.ts, 0, 24)) +>T : Symbol(T, Decl(react.d.ts, 1, 17)) +>U : Symbol(U, Decl(react.d.ts, 1, 19)) } === tests/cases/conformance/jsx/app.tsx === @@ -13,9 +12,9 @@ import * as React from 'react'; export class Text extends React.Component<{}, {}> { >Text : Symbol(Text, Decl(app.tsx, 0, 31)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(app.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) _tagName: string = 'div'; >_tagName : Symbol(Text._tagName, Decl(app.tsx, 2, 51)) diff --git a/tests/baselines/reference/tsxDynamicTagName8.types b/tests/baselines/reference/tsxDynamicTagName8.types index e2d7956a98944..bc7d71e9a6670 100644 --- a/tests/baselines/reference/tsxDynamicTagName8.types +++ b/tests/baselines/reference/tsxDynamicTagName8.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } >Component : Component diff --git a/tests/baselines/reference/tsxDynamicTagName9.js b/tests/baselines/reference/tsxDynamicTagName9.js index e720b2644a09f..e5229f97a39da 100644 --- a/tests/baselines/reference/tsxDynamicTagName9.js +++ b/tests/baselines/reference/tsxDynamicTagName9.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxDynamicTagName9.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxDynamicTagName9.symbols b/tests/baselines/reference/tsxDynamicTagName9.symbols index 436e12057519a..bfb97510885cd 100644 --- a/tests/baselines/reference/tsxDynamicTagName9.symbols +++ b/tests/baselines/reference/tsxDynamicTagName9.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } ->Component : Symbol(Component, Decl(react.d.ts, 1, 24)) ->T : Symbol(T, Decl(react.d.ts, 2, 17)) ->U : Symbol(U, Decl(react.d.ts, 2, 19)) +>Component : Symbol(Component, Decl(react.d.ts, 0, 24)) +>T : Symbol(T, Decl(react.d.ts, 1, 17)) +>U : Symbol(U, Decl(react.d.ts, 1, 19)) } === tests/cases/conformance/jsx/app.tsx === @@ -13,9 +12,9 @@ import * as React from 'react'; export class Text extends React.Component<{}, {}> { >Text : Symbol(Text, Decl(app.tsx, 0, 31)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(app.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) _tagName: "div" = 'div'; >_tagName : Symbol(Text._tagName, Decl(app.tsx, 2, 51)) diff --git a/tests/baselines/reference/tsxDynamicTagName9.types b/tests/baselines/reference/tsxDynamicTagName9.types index e500d3f0ab136..91290dcc3d890 100644 --- a/tests/baselines/reference/tsxDynamicTagName9.types +++ b/tests/baselines/reference/tsxDynamicTagName9.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } >Component : Component diff --git a/tests/baselines/reference/tsxElementResolution.js b/tests/baselines/reference/tsxElementResolution.js index fb606aa4ccc24..6b0f49c19b670 100644 --- a/tests/baselines/reference/tsxElementResolution.js +++ b/tests/baselines/reference/tsxElementResolution.js @@ -1,5 +1,4 @@ //// [tsxElementResolution.tsx] - declare namespace JSX { interface IntrinsicElements { foundFirst: { x: string }; diff --git a/tests/baselines/reference/tsxElementResolution.symbols b/tests/baselines/reference/tsxElementResolution.symbols index 4b3fd175e1961..f69d17a6d0347 100644 --- a/tests/baselines/reference/tsxElementResolution.symbols +++ b/tests/baselines/reference/tsxElementResolution.symbols @@ -1,14 +1,13 @@ === tests/cases/conformance/jsx/tsxElementResolution.tsx === - declare namespace JSX { >JSX : Symbol(JSX, Decl(tsxElementResolution.tsx, 0, 0)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxElementResolution.tsx, 1, 23)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxElementResolution.tsx, 0, 23)) foundFirst: { x: string }; ->foundFirst : Symbol(IntrinsicElements.foundFirst, Decl(tsxElementResolution.tsx, 2, 30)) ->x : Symbol(x, Decl(tsxElementResolution.tsx, 3, 15)) +>foundFirst : Symbol(IntrinsicElements.foundFirst, Decl(tsxElementResolution.tsx, 1, 30)) +>x : Symbol(x, Decl(tsxElementResolution.tsx, 2, 15)) 'string_named'; 'var'; @@ -16,38 +15,38 @@ declare namespace JSX { } class foundFirst { } ->foundFirst : Symbol(foundFirst, Decl(tsxElementResolution.tsx, 7, 1)) +>foundFirst : Symbol(foundFirst, Decl(tsxElementResolution.tsx, 6, 1)) class Other {} ->Other : Symbol(Other, Decl(tsxElementResolution.tsx, 9, 20)) +>Other : Symbol(Other, Decl(tsxElementResolution.tsx, 8, 20)) module Dotted { ->Dotted : Symbol(Dotted, Decl(tsxElementResolution.tsx, 10, 14)) +>Dotted : Symbol(Dotted, Decl(tsxElementResolution.tsx, 9, 14)) export class Name { } ->Name : Symbol(Name, Decl(tsxElementResolution.tsx, 12, 15)) +>Name : Symbol(Name, Decl(tsxElementResolution.tsx, 11, 15)) } // Should find the intrinsic element, not the class element var a = ; ->a : Symbol(a, Decl(tsxElementResolution.tsx, 17, 3)) ->foundFirst : Symbol(JSX.IntrinsicElements.foundFirst, Decl(tsxElementResolution.tsx, 2, 30)) ->x : Symbol(x, Decl(tsxElementResolution.tsx, 17, 19)) +>a : Symbol(a, Decl(tsxElementResolution.tsx, 16, 3)) +>foundFirst : Symbol(JSX.IntrinsicElements.foundFirst, Decl(tsxElementResolution.tsx, 1, 30)) +>x : Symbol(x, Decl(tsxElementResolution.tsx, 16, 19)) var b = ; ->b : Symbol(b, Decl(tsxElementResolution.tsx, 18, 3)) ->string_named : Symbol(JSX.IntrinsicElements['string_named'], Decl(tsxElementResolution.tsx, 3, 28)) +>b : Symbol(b, Decl(tsxElementResolution.tsx, 17, 3)) +>string_named : Symbol(JSX.IntrinsicElements['string_named'], Decl(tsxElementResolution.tsx, 2, 28)) // TODO: This should not be a parse error (should // parse a property name here, not identifier) // var c = ; var d = ; ->d : Symbol(d, Decl(tsxElementResolution.tsx, 22, 3)) ->Other : Symbol(Other, Decl(tsxElementResolution.tsx, 9, 20)) +>d : Symbol(d, Decl(tsxElementResolution.tsx, 21, 3)) +>Other : Symbol(Other, Decl(tsxElementResolution.tsx, 8, 20)) var e = ; ->e : Symbol(e, Decl(tsxElementResolution.tsx, 23, 3)) ->Dotted.Name : Symbol(Dotted.Name, Decl(tsxElementResolution.tsx, 12, 15)) ->Dotted : Symbol(Dotted, Decl(tsxElementResolution.tsx, 10, 14)) ->Name : Symbol(Dotted.Name, Decl(tsxElementResolution.tsx, 12, 15)) +>e : Symbol(e, Decl(tsxElementResolution.tsx, 22, 3)) +>Dotted.Name : Symbol(Dotted.Name, Decl(tsxElementResolution.tsx, 11, 15)) +>Dotted : Symbol(Dotted, Decl(tsxElementResolution.tsx, 9, 14)) +>Name : Symbol(Dotted.Name, Decl(tsxElementResolution.tsx, 11, 15)) diff --git a/tests/baselines/reference/tsxElementResolution.types b/tests/baselines/reference/tsxElementResolution.types index 891ebc37e5d60..df429d1c54dcf 100644 --- a/tests/baselines/reference/tsxElementResolution.types +++ b/tests/baselines/reference/tsxElementResolution.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxElementResolution.tsx === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/tsxElementResolution17.js b/tests/baselines/reference/tsxElementResolution17.js index 899498caf8da4..1f61a441d66b9 100644 --- a/tests/baselines/reference/tsxElementResolution17.js +++ b/tests/baselines/reference/tsxElementResolution17.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxElementResolution17.tsx] //// //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { } diff --git a/tests/baselines/reference/tsxElementResolution17.symbols b/tests/baselines/reference/tsxElementResolution17.symbols index 0225cc35d9141..59deba2c30026 100644 --- a/tests/baselines/reference/tsxElementResolution17.symbols +++ b/tests/baselines/reference/tsxElementResolution17.symbols @@ -8,32 +8,31 @@ import s2 = require('elements2'); >s2 : Symbol(s2, Decl(consumer.tsx, 2, 33)) ; ->s1.MyElement : Symbol(s1.MyElement, Decl(file.tsx, 6, 28)) +>s1.MyElement : Symbol(s1.MyElement, Decl(file.tsx, 5, 28)) >s1 : Symbol(s1, Decl(consumer.tsx, 0, 0)) ->MyElement : Symbol(s1.MyElement, Decl(file.tsx, 6, 28)) +>MyElement : Symbol(s1.MyElement, Decl(file.tsx, 5, 28)) === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(file.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(file.tsx, 1, 20)) +>Element : Symbol(Element, Decl(file.tsx, 0, 20)) interface IntrinsicElements { } ->IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 1, 22)) } declare module 'elements1' { class MyElement { ->MyElement : Symbol(MyElement, Decl(file.tsx, 6, 28)) +>MyElement : Symbol(MyElement, Decl(file.tsx, 5, 28)) } } declare module 'elements2' { class MyElement { ->MyElement : Symbol(MyElement, Decl(file.tsx, 12, 28)) +>MyElement : Symbol(MyElement, Decl(file.tsx, 11, 28)) } } diff --git a/tests/baselines/reference/tsxElementResolution17.types b/tests/baselines/reference/tsxElementResolution17.types index c68c19f58e73a..ab730d7245d1b 100644 --- a/tests/baselines/reference/tsxElementResolution17.types +++ b/tests/baselines/reference/tsxElementResolution17.types @@ -14,7 +14,6 @@ import s2 = require('elements2'); >MyElement : typeof s1.MyElement === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxElementResolution19.js b/tests/baselines/reference/tsxElementResolution19.js index 02136e782dbd5..d63ab29794d2d 100644 --- a/tests/baselines/reference/tsxElementResolution19.js +++ b/tests/baselines/reference/tsxElementResolution19.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxElementResolution19.tsx] //// //// [react.d.ts] - declare module "react" { } @@ -13,7 +12,6 @@ declare module JSX { export class MyClass { } //// [file2.tsx] - // Should not elide React import import * as React from 'react'; import {MyClass} from './file1'; diff --git a/tests/baselines/reference/tsxElementResolution19.symbols b/tests/baselines/reference/tsxElementResolution19.symbols index 48aa4f962b69a..8313a8aa4beb7 100644 --- a/tests/baselines/reference/tsxElementResolution19.symbols +++ b/tests/baselines/reference/tsxElementResolution19.symbols @@ -1,6 +1,5 @@ === tests/cases/conformance/jsx/react.d.ts === - -No type information for this code.declare module "react" { +declare module "react" { No type information for this code. No type information for this code.} No type information for this code. @@ -15,14 +14,13 @@ export class MyClass { } >MyClass : Symbol(MyClass, Decl(file1.tsx, 2, 1)) === tests/cases/conformance/jsx/file2.tsx === - // Should not elide React import import * as React from 'react'; ->React : Symbol(React, Decl(file2.tsx, 2, 6)) +>React : Symbol(React, Decl(file2.tsx, 1, 6)) import {MyClass} from './file1'; ->MyClass : Symbol(MyClass, Decl(file2.tsx, 3, 8)) +>MyClass : Symbol(MyClass, Decl(file2.tsx, 2, 8)) ; ->MyClass : Symbol(MyClass, Decl(file2.tsx, 3, 8)) +>MyClass : Symbol(MyClass, Decl(file2.tsx, 2, 8)) diff --git a/tests/baselines/reference/tsxElementResolution19.types b/tests/baselines/reference/tsxElementResolution19.types index 0fa1eefe5f63c..6539bfd59087b 100644 --- a/tests/baselines/reference/tsxElementResolution19.types +++ b/tests/baselines/reference/tsxElementResolution19.types @@ -1,6 +1,5 @@ === tests/cases/conformance/jsx/react.d.ts === - -No type information for this code.declare module "react" { +declare module "react" { No type information for this code. No type information for this code.} No type information for this code. @@ -15,7 +14,6 @@ export class MyClass { } >MyClass : MyClass === tests/cases/conformance/jsx/file2.tsx === - // Should not elide React import import * as React from 'react'; >React : typeof React diff --git a/tests/baselines/reference/tsxEmit3.errors.txt b/tests/baselines/reference/tsxEmit3.errors.txt index bef4d8d4efcbe..aa32c5c9afd68 100644 --- a/tests/baselines/reference/tsxEmit3.errors.txt +++ b/tests/baselines/reference/tsxEmit3.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/jsx/file.tsx(19,2): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/jsx/file.tsx(23,3): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/jsx/file.tsx(26,3): error TS2695: Left side of comma operator is unused and has no side effects. -tests/cases/conformance/jsx/file.tsx(39,2): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file.tsx(18,2): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file.tsx(22,3): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file.tsx(25,3): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file.tsx(38,2): error TS2695: Left side of comma operator is unused and has no side effects. ==== tests/cases/conformance/jsx/file.tsx (4 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { } diff --git a/tests/baselines/reference/tsxEmit3.js b/tests/baselines/reference/tsxEmit3.js index bf368f9b26286..402782f899d17 100644 --- a/tests/baselines/reference/tsxEmit3.js +++ b/tests/baselines/reference/tsxEmit3.js @@ -1,5 +1,4 @@ //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { } diff --git a/tests/baselines/reference/tsxEmit3.js.map b/tests/baselines/reference/tsxEmit3.js.map index 6e12addfb6b56..bdada1ee7bb5d 100644 --- a/tests/baselines/reference/tsxEmit3.js.map +++ b/tests/baselines/reference/tsxEmit3.js.map @@ -1,2 +1,2 @@ //// [file.jsx.map] -{"version":3,"file":"file.jsx","sourceRoot":"","sources":["file.tsx"],"names":[],"mappings":"AAMA,IAAO,CAAC,CAQP;AARD,WAAO,CAAC;IACP;QAAmB;QAAgB,CAAC;QAAC,UAAC;IAAD,CAAC,AAAtC,IAAsC;IAAzB,KAAG,MAAsB,CAAA;IACtC,IAAc,CAAC,CAKd;IALD,WAAc,CAAC;QACd;YAAA;YAAmB,CAAC;YAAD,UAAC;QAAD,CAAC,AAApB,IAAoB;QAAP,KAAG,MAAI,CAAA;QAEpB,WAAW;QACX,gBAAgB;IACjB,CAAC,EALa,CAAC,GAAD,GAAC,KAAD,GAAC,QAKd;AACF,CAAC,EARM,CAAC,KAAD,CAAC,QAQP;AAED,WAAO,CAAC;IACP,aAAa;IACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;IAEb,IAAc,CAAC,CAMd;IAND,WAAc,CAAC;QACd,aAAa;QACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;QAEb,aAAa;QACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;IACd,CAAC,EANa,CAAC,GAAD,GAAC,KAAD,GAAC,QAMd;AAEF,CAAC,EAZM,CAAC,KAAD,CAAC,QAYP;AAED,WAAO,CAAC;IACP,eAAe;IACf,EAAA,CAAC,CAAC,GAAG,EAAE,CAAC,EAAA,CAAC,CAAC,GAAG,GAAG,CAAC;AAClB,CAAC,EAHM,CAAC,KAAD,CAAC,QAGP;AAED,WAAO,GAAC;IACP,IAAI,CAAC,GAAG,GAAG,CAAC;IACZ,eAAe;IACf,IAAA,GAAG,EAAE,CAAC,IAAA,GAAG,GAAG,CAAC;AACd,CAAC,EAJM,CAAC,KAAD,CAAC,QAIP"} \ No newline at end of file +{"version":3,"file":"file.jsx","sourceRoot":"","sources":["file.tsx"],"names":[],"mappings":"AAKA,IAAO,CAAC,CAQP;AARD,WAAO,CAAC;IACP;QAAmB;QAAgB,CAAC;QAAC,UAAC;IAAD,CAAC,AAAtC,IAAsC;IAAzB,KAAG,MAAsB,CAAA;IACtC,IAAc,CAAC,CAKd;IALD,WAAc,CAAC;QACd;YAAA;YAAmB,CAAC;YAAD,UAAC;QAAD,CAAC,AAApB,IAAoB;QAAP,KAAG,MAAI,CAAA;QAEpB,WAAW;QACX,gBAAgB;IACjB,CAAC,EALa,CAAC,GAAD,GAAC,KAAD,GAAC,QAKd;AACF,CAAC,EARM,CAAC,KAAD,CAAC,QAQP;AAED,WAAO,CAAC;IACP,aAAa;IACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;IAEb,IAAc,CAAC,CAMd;IAND,WAAc,CAAC;QACd,aAAa;QACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;QAEb,aAAa;QACb,EAAA,GAAG,EAAE,CAAC,EAAA,GAAG,GAAG,CAAC;IACd,CAAC,EANa,CAAC,GAAD,GAAC,KAAD,GAAC,QAMd;AAEF,CAAC,EAZM,CAAC,KAAD,CAAC,QAYP;AAED,WAAO,CAAC;IACP,eAAe;IACf,EAAA,CAAC,CAAC,GAAG,EAAE,CAAC,EAAA,CAAC,CAAC,GAAG,GAAG,CAAC;AAClB,CAAC,EAHM,CAAC,KAAD,CAAC,QAGP;AAED,WAAO,GAAC;IACP,IAAI,CAAC,GAAG,GAAG,CAAC;IACZ,eAAe;IACf,IAAA,GAAG,EAAE,CAAC,IAAA,GAAG,GAAG,CAAC;AACd,CAAC,EAJM,CAAC,KAAD,CAAC,QAIP"} \ No newline at end of file diff --git a/tests/baselines/reference/tsxEmit3.sourcemap.txt b/tests/baselines/reference/tsxEmit3.sourcemap.txt index d2ccdb264ba60..91bc3b839af02 100644 --- a/tests/baselines/reference/tsxEmit3.sourcemap.txt +++ b/tests/baselines/reference/tsxEmit3.sourcemap.txt @@ -14,8 +14,7 @@ sourceFile:file.tsx 3 > ^ 4 > ^ 5 > ^^^^^^^^^^-> -1 > - >declare module JSX { +1 >declare module JSX { > interface Element { } > interface IntrinsicElements { } >} @@ -32,10 +31,10 @@ sourceFile:file.tsx > // Foo, ; > } > } -1 >Emitted(1, 1) Source(7, 1) + SourceIndex(0) -2 >Emitted(1, 5) Source(7, 8) + SourceIndex(0) -3 >Emitted(1, 6) Source(7, 9) + SourceIndex(0) -4 >Emitted(1, 7) Source(15, 2) + SourceIndex(0) +1 >Emitted(1, 1) Source(6, 1) + SourceIndex(0) +2 >Emitted(1, 5) Source(6, 8) + SourceIndex(0) +3 >Emitted(1, 6) Source(6, 9) + SourceIndex(0) +4 >Emitted(1, 7) Source(14, 2) + SourceIndex(0) --- >>>(function (M) { 1-> @@ -45,22 +44,22 @@ sourceFile:file.tsx 1-> 2 >module 3 > M -1->Emitted(2, 1) Source(7, 1) + SourceIndex(0) -2 >Emitted(2, 12) Source(7, 8) + SourceIndex(0) -3 >Emitted(2, 13) Source(7, 9) + SourceIndex(0) +1->Emitted(2, 1) Source(6, 1) + SourceIndex(0) +2 >Emitted(2, 12) Source(6, 8) + SourceIndex(0) +3 >Emitted(2, 13) Source(6, 9) + SourceIndex(0) --- >>> var Foo = (function () { 1->^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^-> 1-> { > -1->Emitted(3, 5) Source(8, 2) + SourceIndex(0) +1->Emitted(3, 5) Source(7, 2) + SourceIndex(0) --- >>> function Foo() { 1->^^^^^^^^ 2 > ^^-> 1->export class Foo { -1->Emitted(4, 9) Source(8, 21) + SourceIndex(0) +1->Emitted(4, 9) Source(7, 21) + SourceIndex(0) --- >>> } 1->^^^^^^^^ @@ -68,16 +67,16 @@ sourceFile:file.tsx 3 > ^^^^^^^^^^^-> 1->constructor() { 2 > } -1->Emitted(5, 9) Source(8, 37) + SourceIndex(0) -2 >Emitted(5, 10) Source(8, 38) + SourceIndex(0) +1->Emitted(5, 9) Source(7, 37) + SourceIndex(0) +2 >Emitted(5, 10) Source(7, 38) + SourceIndex(0) --- >>> return Foo; 1->^^^^^^^^ 2 > ^^^^^^^^^^ 1-> 2 > } -1->Emitted(6, 9) Source(8, 39) + SourceIndex(0) -2 >Emitted(6, 19) Source(8, 40) + SourceIndex(0) +1->Emitted(6, 9) Source(7, 39) + SourceIndex(0) +2 >Emitted(6, 19) Source(7, 40) + SourceIndex(0) --- >>> }()); 1 >^^^^ @@ -89,10 +88,10 @@ sourceFile:file.tsx 2 > } 3 > 4 > export class Foo { constructor() { } } -1 >Emitted(7, 5) Source(8, 39) + SourceIndex(0) -2 >Emitted(7, 6) Source(8, 40) + SourceIndex(0) -3 >Emitted(7, 6) Source(8, 2) + SourceIndex(0) -4 >Emitted(7, 10) Source(8, 40) + SourceIndex(0) +1 >Emitted(7, 5) Source(7, 39) + SourceIndex(0) +2 >Emitted(7, 6) Source(7, 40) + SourceIndex(0) +3 >Emitted(7, 6) Source(7, 2) + SourceIndex(0) +4 >Emitted(7, 10) Source(7, 40) + SourceIndex(0) --- >>> M.Foo = Foo; 1->^^^^ @@ -103,10 +102,10 @@ sourceFile:file.tsx 2 > Foo 3 > { constructor() { } } 4 > -1->Emitted(8, 5) Source(8, 15) + SourceIndex(0) -2 >Emitted(8, 10) Source(8, 18) + SourceIndex(0) -3 >Emitted(8, 16) Source(8, 40) + SourceIndex(0) -4 >Emitted(8, 17) Source(8, 40) + SourceIndex(0) +1->Emitted(8, 5) Source(7, 15) + SourceIndex(0) +2 >Emitted(8, 10) Source(7, 18) + SourceIndex(0) +3 >Emitted(8, 16) Source(7, 40) + SourceIndex(0) +4 >Emitted(8, 17) Source(7, 40) + SourceIndex(0) --- >>> var S; 1 >^^^^ @@ -124,10 +123,10 @@ sourceFile:file.tsx > // Emit Foo > // Foo, ; > } -1 >Emitted(9, 5) Source(9, 2) + SourceIndex(0) -2 >Emitted(9, 9) Source(9, 16) + SourceIndex(0) -3 >Emitted(9, 10) Source(9, 17) + SourceIndex(0) -4 >Emitted(9, 11) Source(14, 3) + SourceIndex(0) +1 >Emitted(9, 5) Source(8, 2) + SourceIndex(0) +2 >Emitted(9, 9) Source(8, 16) + SourceIndex(0) +3 >Emitted(9, 10) Source(8, 17) + SourceIndex(0) +4 >Emitted(9, 11) Source(13, 3) + SourceIndex(0) --- >>> (function (S) { 1->^^^^ @@ -137,22 +136,22 @@ sourceFile:file.tsx 1-> 2 > export module 3 > S -1->Emitted(10, 5) Source(9, 2) + SourceIndex(0) -2 >Emitted(10, 16) Source(9, 16) + SourceIndex(0) -3 >Emitted(10, 17) Source(9, 17) + SourceIndex(0) +1->Emitted(10, 5) Source(8, 2) + SourceIndex(0) +2 >Emitted(10, 16) Source(8, 16) + SourceIndex(0) +3 >Emitted(10, 17) Source(8, 17) + SourceIndex(0) --- >>> var Bar = (function () { 1->^^^^^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^-> 1-> { > -1->Emitted(11, 9) Source(10, 3) + SourceIndex(0) +1->Emitted(11, 9) Source(9, 3) + SourceIndex(0) --- >>> function Bar() { 1->^^^^^^^^^^^^ 2 > ^^-> 1-> -1->Emitted(12, 13) Source(10, 3) + SourceIndex(0) +1->Emitted(12, 13) Source(9, 3) + SourceIndex(0) --- >>> } 1->^^^^^^^^^^^^ @@ -160,16 +159,16 @@ sourceFile:file.tsx 3 > ^^^^^^^^^^^-> 1->export class Bar { 2 > } -1->Emitted(13, 13) Source(10, 22) + SourceIndex(0) -2 >Emitted(13, 14) Source(10, 23) + SourceIndex(0) +1->Emitted(13, 13) Source(9, 22) + SourceIndex(0) +2 >Emitted(13, 14) Source(9, 23) + SourceIndex(0) --- >>> return Bar; 1->^^^^^^^^^^^^ 2 > ^^^^^^^^^^ 1-> 2 > } -1->Emitted(14, 13) Source(10, 22) + SourceIndex(0) -2 >Emitted(14, 23) Source(10, 23) + SourceIndex(0) +1->Emitted(14, 13) Source(9, 22) + SourceIndex(0) +2 >Emitted(14, 23) Source(9, 23) + SourceIndex(0) --- >>> }()); 1 >^^^^^^^^ @@ -181,10 +180,10 @@ sourceFile:file.tsx 2 > } 3 > 4 > export class Bar { } -1 >Emitted(15, 9) Source(10, 22) + SourceIndex(0) -2 >Emitted(15, 10) Source(10, 23) + SourceIndex(0) -3 >Emitted(15, 10) Source(10, 3) + SourceIndex(0) -4 >Emitted(15, 14) Source(10, 23) + SourceIndex(0) +1 >Emitted(15, 9) Source(9, 22) + SourceIndex(0) +2 >Emitted(15, 10) Source(9, 23) + SourceIndex(0) +3 >Emitted(15, 10) Source(9, 3) + SourceIndex(0) +4 >Emitted(15, 14) Source(9, 23) + SourceIndex(0) --- >>> S.Bar = Bar; 1->^^^^^^^^ @@ -195,10 +194,10 @@ sourceFile:file.tsx 2 > Bar 3 > { } 4 > -1->Emitted(16, 9) Source(10, 16) + SourceIndex(0) -2 >Emitted(16, 14) Source(10, 19) + SourceIndex(0) -3 >Emitted(16, 20) Source(10, 23) + SourceIndex(0) -4 >Emitted(16, 21) Source(10, 23) + SourceIndex(0) +1->Emitted(16, 9) Source(9, 16) + SourceIndex(0) +2 >Emitted(16, 14) Source(9, 19) + SourceIndex(0) +3 >Emitted(16, 20) Source(9, 23) + SourceIndex(0) +4 >Emitted(16, 21) Source(9, 23) + SourceIndex(0) --- >>> // Emit Foo 1 >^^^^^^^^ @@ -208,8 +207,8 @@ sourceFile:file.tsx > > 2 > // Emit Foo -1 >Emitted(17, 9) Source(12, 3) + SourceIndex(0) -2 >Emitted(17, 20) Source(12, 14) + SourceIndex(0) +1 >Emitted(17, 9) Source(11, 3) + SourceIndex(0) +2 >Emitted(17, 20) Source(11, 14) + SourceIndex(0) --- >>> // Foo, ; 1->^^^^^^^^ @@ -218,8 +217,8 @@ sourceFile:file.tsx 1-> > 2 > // Foo, ; -1->Emitted(18, 9) Source(13, 3) + SourceIndex(0) -2 >Emitted(18, 25) Source(13, 19) + SourceIndex(0) +1->Emitted(18, 9) Source(12, 3) + SourceIndex(0) +2 >Emitted(18, 25) Source(12, 19) + SourceIndex(0) --- >>> })(S = M.S || (M.S = {})); 1->^^^^ @@ -246,15 +245,15 @@ sourceFile:file.tsx > // Emit Foo > // Foo, ; > } -1->Emitted(19, 5) Source(14, 2) + SourceIndex(0) -2 >Emitted(19, 6) Source(14, 3) + SourceIndex(0) -3 >Emitted(19, 8) Source(9, 16) + SourceIndex(0) -4 >Emitted(19, 9) Source(9, 17) + SourceIndex(0) -5 >Emitted(19, 12) Source(9, 16) + SourceIndex(0) -6 >Emitted(19, 15) Source(9, 17) + SourceIndex(0) -7 >Emitted(19, 20) Source(9, 16) + SourceIndex(0) -8 >Emitted(19, 23) Source(9, 17) + SourceIndex(0) -9 >Emitted(19, 31) Source(14, 3) + SourceIndex(0) +1->Emitted(19, 5) Source(13, 2) + SourceIndex(0) +2 >Emitted(19, 6) Source(13, 3) + SourceIndex(0) +3 >Emitted(19, 8) Source(8, 16) + SourceIndex(0) +4 >Emitted(19, 9) Source(8, 17) + SourceIndex(0) +5 >Emitted(19, 12) Source(8, 16) + SourceIndex(0) +6 >Emitted(19, 15) Source(8, 17) + SourceIndex(0) +7 >Emitted(19, 20) Source(8, 16) + SourceIndex(0) +8 >Emitted(19, 23) Source(8, 17) + SourceIndex(0) +9 >Emitted(19, 31) Source(13, 3) + SourceIndex(0) --- >>>})(M || (M = {})); 1 > @@ -280,13 +279,13 @@ sourceFile:file.tsx > // Foo, ; > } > } -1 >Emitted(20, 1) Source(15, 1) + SourceIndex(0) -2 >Emitted(20, 2) Source(15, 2) + SourceIndex(0) -3 >Emitted(20, 4) Source(7, 8) + SourceIndex(0) -4 >Emitted(20, 5) Source(7, 9) + SourceIndex(0) -5 >Emitted(20, 10) Source(7, 8) + SourceIndex(0) -6 >Emitted(20, 11) Source(7, 9) + SourceIndex(0) -7 >Emitted(20, 19) Source(15, 2) + SourceIndex(0) +1 >Emitted(20, 1) Source(14, 1) + SourceIndex(0) +2 >Emitted(20, 2) Source(14, 2) + SourceIndex(0) +3 >Emitted(20, 4) Source(6, 8) + SourceIndex(0) +4 >Emitted(20, 5) Source(6, 9) + SourceIndex(0) +5 >Emitted(20, 10) Source(6, 8) + SourceIndex(0) +6 >Emitted(20, 11) Source(6, 9) + SourceIndex(0) +7 >Emitted(20, 19) Source(14, 2) + SourceIndex(0) --- >>>(function (M) { 1 > @@ -298,9 +297,9 @@ sourceFile:file.tsx > 2 >module 3 > M -1 >Emitted(21, 1) Source(17, 1) + SourceIndex(0) -2 >Emitted(21, 12) Source(17, 8) + SourceIndex(0) -3 >Emitted(21, 13) Source(17, 9) + SourceIndex(0) +1 >Emitted(21, 1) Source(16, 1) + SourceIndex(0) +2 >Emitted(21, 12) Source(16, 8) + SourceIndex(0) +3 >Emitted(21, 13) Source(16, 9) + SourceIndex(0) --- >>> // Emit M.Foo 1->^^^^ @@ -309,8 +308,8 @@ sourceFile:file.tsx 1-> { > 2 > // Emit M.Foo -1->Emitted(22, 5) Source(18, 2) + SourceIndex(0) -2 >Emitted(22, 18) Source(18, 15) + SourceIndex(0) +1->Emitted(22, 5) Source(17, 2) + SourceIndex(0) +2 >Emitted(22, 18) Source(17, 15) + SourceIndex(0) --- >>> M.Foo, ; 1->^^^^ @@ -332,15 +331,15 @@ sourceFile:file.tsx 7 > Foo 8 > /> 9 > ; -1->Emitted(23, 5) Source(19, 2) + SourceIndex(0) -2 >Emitted(23, 7) Source(19, 2) + SourceIndex(0) -3 >Emitted(23, 10) Source(19, 5) + SourceIndex(0) -4 >Emitted(23, 12) Source(19, 7) + SourceIndex(0) -5 >Emitted(23, 13) Source(19, 8) + SourceIndex(0) -6 >Emitted(23, 15) Source(19, 8) + SourceIndex(0) -7 >Emitted(23, 18) Source(19, 11) + SourceIndex(0) -8 >Emitted(23, 21) Source(19, 14) + SourceIndex(0) -9 >Emitted(23, 22) Source(19, 15) + SourceIndex(0) +1->Emitted(23, 5) Source(18, 2) + SourceIndex(0) +2 >Emitted(23, 7) Source(18, 2) + SourceIndex(0) +3 >Emitted(23, 10) Source(18, 5) + SourceIndex(0) +4 >Emitted(23, 12) Source(18, 7) + SourceIndex(0) +5 >Emitted(23, 13) Source(18, 8) + SourceIndex(0) +6 >Emitted(23, 15) Source(18, 8) + SourceIndex(0) +7 >Emitted(23, 18) Source(18, 11) + SourceIndex(0) +8 >Emitted(23, 21) Source(18, 14) + SourceIndex(0) +9 >Emitted(23, 22) Source(18, 15) + SourceIndex(0) --- >>> var S; 1 >^^^^ @@ -360,10 +359,10 @@ sourceFile:file.tsx > // Emit S.Bar > Bar, ; > } -1 >Emitted(24, 5) Source(21, 2) + SourceIndex(0) -2 >Emitted(24, 9) Source(21, 16) + SourceIndex(0) -3 >Emitted(24, 10) Source(21, 17) + SourceIndex(0) -4 >Emitted(24, 11) Source(27, 3) + SourceIndex(0) +1 >Emitted(24, 5) Source(20, 2) + SourceIndex(0) +2 >Emitted(24, 9) Source(20, 16) + SourceIndex(0) +3 >Emitted(24, 10) Source(20, 17) + SourceIndex(0) +4 >Emitted(24, 11) Source(26, 3) + SourceIndex(0) --- >>> (function (S) { 1->^^^^ @@ -373,9 +372,9 @@ sourceFile:file.tsx 1-> 2 > export module 3 > S -1->Emitted(25, 5) Source(21, 2) + SourceIndex(0) -2 >Emitted(25, 16) Source(21, 16) + SourceIndex(0) -3 >Emitted(25, 17) Source(21, 17) + SourceIndex(0) +1->Emitted(25, 5) Source(20, 2) + SourceIndex(0) +2 >Emitted(25, 16) Source(20, 16) + SourceIndex(0) +3 >Emitted(25, 17) Source(20, 17) + SourceIndex(0) --- >>> // Emit M.Foo 1->^^^^^^^^ @@ -384,8 +383,8 @@ sourceFile:file.tsx 1-> { > 2 > // Emit M.Foo -1->Emitted(26, 9) Source(22, 3) + SourceIndex(0) -2 >Emitted(26, 22) Source(22, 16) + SourceIndex(0) +1->Emitted(26, 9) Source(21, 3) + SourceIndex(0) +2 >Emitted(26, 22) Source(21, 16) + SourceIndex(0) --- >>> M.Foo, ; 1->^^^^^^^^ @@ -407,15 +406,15 @@ sourceFile:file.tsx 7 > Foo 8 > /> 9 > ; -1->Emitted(27, 9) Source(23, 3) + SourceIndex(0) -2 >Emitted(27, 11) Source(23, 3) + SourceIndex(0) -3 >Emitted(27, 14) Source(23, 6) + SourceIndex(0) -4 >Emitted(27, 16) Source(23, 8) + SourceIndex(0) -5 >Emitted(27, 17) Source(23, 9) + SourceIndex(0) -6 >Emitted(27, 19) Source(23, 9) + SourceIndex(0) -7 >Emitted(27, 22) Source(23, 12) + SourceIndex(0) -8 >Emitted(27, 25) Source(23, 15) + SourceIndex(0) -9 >Emitted(27, 26) Source(23, 16) + SourceIndex(0) +1->Emitted(27, 9) Source(22, 3) + SourceIndex(0) +2 >Emitted(27, 11) Source(22, 3) + SourceIndex(0) +3 >Emitted(27, 14) Source(22, 6) + SourceIndex(0) +4 >Emitted(27, 16) Source(22, 8) + SourceIndex(0) +5 >Emitted(27, 17) Source(22, 9) + SourceIndex(0) +6 >Emitted(27, 19) Source(22, 9) + SourceIndex(0) +7 >Emitted(27, 22) Source(22, 12) + SourceIndex(0) +8 >Emitted(27, 25) Source(22, 15) + SourceIndex(0) +9 >Emitted(27, 26) Source(22, 16) + SourceIndex(0) --- >>> // Emit S.Bar 1 >^^^^^^^^ @@ -425,8 +424,8 @@ sourceFile:file.tsx > > 2 > // Emit S.Bar -1 >Emitted(28, 9) Source(25, 3) + SourceIndex(0) -2 >Emitted(28, 22) Source(25, 16) + SourceIndex(0) +1 >Emitted(28, 9) Source(24, 3) + SourceIndex(0) +2 >Emitted(28, 22) Source(24, 16) + SourceIndex(0) --- >>> S.Bar, ; 1->^^^^^^^^ @@ -449,15 +448,15 @@ sourceFile:file.tsx 7 > Bar 8 > /> 9 > ; -1->Emitted(29, 9) Source(26, 3) + SourceIndex(0) -2 >Emitted(29, 11) Source(26, 3) + SourceIndex(0) -3 >Emitted(29, 14) Source(26, 6) + SourceIndex(0) -4 >Emitted(29, 16) Source(26, 8) + SourceIndex(0) -5 >Emitted(29, 17) Source(26, 9) + SourceIndex(0) -6 >Emitted(29, 19) Source(26, 9) + SourceIndex(0) -7 >Emitted(29, 22) Source(26, 12) + SourceIndex(0) -8 >Emitted(29, 25) Source(26, 15) + SourceIndex(0) -9 >Emitted(29, 26) Source(26, 16) + SourceIndex(0) +1->Emitted(29, 9) Source(25, 3) + SourceIndex(0) +2 >Emitted(29, 11) Source(25, 3) + SourceIndex(0) +3 >Emitted(29, 14) Source(25, 6) + SourceIndex(0) +4 >Emitted(29, 16) Source(25, 8) + SourceIndex(0) +5 >Emitted(29, 17) Source(25, 9) + SourceIndex(0) +6 >Emitted(29, 19) Source(25, 9) + SourceIndex(0) +7 >Emitted(29, 22) Source(25, 12) + SourceIndex(0) +8 >Emitted(29, 25) Source(25, 15) + SourceIndex(0) +9 >Emitted(29, 26) Source(25, 16) + SourceIndex(0) --- >>> })(S = M.S || (M.S = {})); 1->^^^^ @@ -485,15 +484,15 @@ sourceFile:file.tsx > // Emit S.Bar > Bar, ; > } -1->Emitted(30, 5) Source(27, 2) + SourceIndex(0) -2 >Emitted(30, 6) Source(27, 3) + SourceIndex(0) -3 >Emitted(30, 8) Source(21, 16) + SourceIndex(0) -4 >Emitted(30, 9) Source(21, 17) + SourceIndex(0) -5 >Emitted(30, 12) Source(21, 16) + SourceIndex(0) -6 >Emitted(30, 15) Source(21, 17) + SourceIndex(0) -7 >Emitted(30, 20) Source(21, 16) + SourceIndex(0) -8 >Emitted(30, 23) Source(21, 17) + SourceIndex(0) -9 >Emitted(30, 31) Source(27, 3) + SourceIndex(0) +1->Emitted(30, 5) Source(26, 2) + SourceIndex(0) +2 >Emitted(30, 6) Source(26, 3) + SourceIndex(0) +3 >Emitted(30, 8) Source(20, 16) + SourceIndex(0) +4 >Emitted(30, 9) Source(20, 17) + SourceIndex(0) +5 >Emitted(30, 12) Source(20, 16) + SourceIndex(0) +6 >Emitted(30, 15) Source(20, 17) + SourceIndex(0) +7 >Emitted(30, 20) Source(20, 16) + SourceIndex(0) +8 >Emitted(30, 23) Source(20, 17) + SourceIndex(0) +9 >Emitted(30, 31) Source(26, 3) + SourceIndex(0) --- >>>})(M || (M = {})); 1 > @@ -524,13 +523,13 @@ sourceFile:file.tsx > } > > } -1 >Emitted(31, 1) Source(29, 1) + SourceIndex(0) -2 >Emitted(31, 2) Source(29, 2) + SourceIndex(0) -3 >Emitted(31, 4) Source(17, 8) + SourceIndex(0) -4 >Emitted(31, 5) Source(17, 9) + SourceIndex(0) -5 >Emitted(31, 10) Source(17, 8) + SourceIndex(0) -6 >Emitted(31, 11) Source(17, 9) + SourceIndex(0) -7 >Emitted(31, 19) Source(29, 2) + SourceIndex(0) +1 >Emitted(31, 1) Source(28, 1) + SourceIndex(0) +2 >Emitted(31, 2) Source(28, 2) + SourceIndex(0) +3 >Emitted(31, 4) Source(16, 8) + SourceIndex(0) +4 >Emitted(31, 5) Source(16, 9) + SourceIndex(0) +5 >Emitted(31, 10) Source(16, 8) + SourceIndex(0) +6 >Emitted(31, 11) Source(16, 9) + SourceIndex(0) +7 >Emitted(31, 19) Source(28, 2) + SourceIndex(0) --- >>>(function (M) { 1 > @@ -542,9 +541,9 @@ sourceFile:file.tsx > 2 >module 3 > M -1 >Emitted(32, 1) Source(31, 1) + SourceIndex(0) -2 >Emitted(32, 12) Source(31, 8) + SourceIndex(0) -3 >Emitted(32, 13) Source(31, 9) + SourceIndex(0) +1 >Emitted(32, 1) Source(30, 1) + SourceIndex(0) +2 >Emitted(32, 12) Source(30, 8) + SourceIndex(0) +3 >Emitted(32, 13) Source(30, 9) + SourceIndex(0) --- >>> // Emit M.S.Bar 1->^^^^ @@ -553,8 +552,8 @@ sourceFile:file.tsx 1-> { > 2 > // Emit M.S.Bar -1->Emitted(33, 5) Source(32, 2) + SourceIndex(0) -2 >Emitted(33, 20) Source(32, 17) + SourceIndex(0) +1->Emitted(33, 5) Source(31, 2) + SourceIndex(0) +2 >Emitted(33, 20) Source(31, 17) + SourceIndex(0) --- >>> M.S.Bar, ; 1->^^^^ @@ -584,19 +583,19 @@ sourceFile:file.tsx 11> Bar 12> /> 13> ; -1->Emitted(34, 5) Source(33, 2) + SourceIndex(0) -2 >Emitted(34, 7) Source(33, 2) + SourceIndex(0) -3 >Emitted(34, 8) Source(33, 3) + SourceIndex(0) -4 >Emitted(34, 9) Source(33, 4) + SourceIndex(0) -5 >Emitted(34, 12) Source(33, 7) + SourceIndex(0) -6 >Emitted(34, 14) Source(33, 9) + SourceIndex(0) -7 >Emitted(34, 15) Source(33, 10) + SourceIndex(0) -8 >Emitted(34, 17) Source(33, 10) + SourceIndex(0) -9 >Emitted(34, 18) Source(33, 11) + SourceIndex(0) -10>Emitted(34, 19) Source(33, 12) + SourceIndex(0) -11>Emitted(34, 22) Source(33, 15) + SourceIndex(0) -12>Emitted(34, 25) Source(33, 18) + SourceIndex(0) -13>Emitted(34, 26) Source(33, 19) + SourceIndex(0) +1->Emitted(34, 5) Source(32, 2) + SourceIndex(0) +2 >Emitted(34, 7) Source(32, 2) + SourceIndex(0) +3 >Emitted(34, 8) Source(32, 3) + SourceIndex(0) +4 >Emitted(34, 9) Source(32, 4) + SourceIndex(0) +5 >Emitted(34, 12) Source(32, 7) + SourceIndex(0) +6 >Emitted(34, 14) Source(32, 9) + SourceIndex(0) +7 >Emitted(34, 15) Source(32, 10) + SourceIndex(0) +8 >Emitted(34, 17) Source(32, 10) + SourceIndex(0) +9 >Emitted(34, 18) Source(32, 11) + SourceIndex(0) +10>Emitted(34, 19) Source(32, 12) + SourceIndex(0) +11>Emitted(34, 22) Source(32, 15) + SourceIndex(0) +12>Emitted(34, 25) Source(32, 18) + SourceIndex(0) +13>Emitted(34, 26) Source(32, 19) + SourceIndex(0) --- >>>})(M || (M = {})); 1 > @@ -617,13 +616,13 @@ sourceFile:file.tsx > // Emit M.S.Bar > S.Bar, ; > } -1 >Emitted(35, 1) Source(34, 1) + SourceIndex(0) -2 >Emitted(35, 2) Source(34, 2) + SourceIndex(0) -3 >Emitted(35, 4) Source(31, 8) + SourceIndex(0) -4 >Emitted(35, 5) Source(31, 9) + SourceIndex(0) -5 >Emitted(35, 10) Source(31, 8) + SourceIndex(0) -6 >Emitted(35, 11) Source(31, 9) + SourceIndex(0) -7 >Emitted(35, 19) Source(34, 2) + SourceIndex(0) +1 >Emitted(35, 1) Source(33, 1) + SourceIndex(0) +2 >Emitted(35, 2) Source(33, 2) + SourceIndex(0) +3 >Emitted(35, 4) Source(30, 8) + SourceIndex(0) +4 >Emitted(35, 5) Source(30, 9) + SourceIndex(0) +5 >Emitted(35, 10) Source(30, 8) + SourceIndex(0) +6 >Emitted(35, 11) Source(30, 9) + SourceIndex(0) +7 >Emitted(35, 19) Source(33, 2) + SourceIndex(0) --- >>>(function (M_1) { 1 > @@ -635,9 +634,9 @@ sourceFile:file.tsx > 2 >module 3 > M -1 >Emitted(36, 1) Source(36, 1) + SourceIndex(0) -2 >Emitted(36, 12) Source(36, 8) + SourceIndex(0) -3 >Emitted(36, 15) Source(36, 9) + SourceIndex(0) +1 >Emitted(36, 1) Source(35, 1) + SourceIndex(0) +2 >Emitted(36, 12) Source(35, 8) + SourceIndex(0) +3 >Emitted(36, 15) Source(35, 9) + SourceIndex(0) --- >>> var M = 100; 1->^^^^ @@ -654,12 +653,12 @@ sourceFile:file.tsx 4 > = 5 > 100 6 > ; -1->Emitted(37, 5) Source(37, 2) + SourceIndex(0) -2 >Emitted(37, 9) Source(37, 6) + SourceIndex(0) -3 >Emitted(37, 10) Source(37, 7) + SourceIndex(0) -4 >Emitted(37, 13) Source(37, 10) + SourceIndex(0) -5 >Emitted(37, 16) Source(37, 13) + SourceIndex(0) -6 >Emitted(37, 17) Source(37, 14) + SourceIndex(0) +1->Emitted(37, 5) Source(36, 2) + SourceIndex(0) +2 >Emitted(37, 9) Source(36, 6) + SourceIndex(0) +3 >Emitted(37, 10) Source(36, 7) + SourceIndex(0) +4 >Emitted(37, 13) Source(36, 10) + SourceIndex(0) +5 >Emitted(37, 16) Source(36, 13) + SourceIndex(0) +6 >Emitted(37, 17) Source(36, 14) + SourceIndex(0) --- >>> // Emit M_1.Foo 1->^^^^ @@ -668,8 +667,8 @@ sourceFile:file.tsx 1-> > 2 > // Emit M_1.Foo -1->Emitted(38, 5) Source(38, 2) + SourceIndex(0) -2 >Emitted(38, 20) Source(38, 17) + SourceIndex(0) +1->Emitted(38, 5) Source(37, 2) + SourceIndex(0) +2 >Emitted(38, 20) Source(37, 17) + SourceIndex(0) --- >>> M_1.Foo, ; 1->^^^^ @@ -691,15 +690,15 @@ sourceFile:file.tsx 7 > Foo 8 > /> 9 > ; -1->Emitted(39, 5) Source(39, 2) + SourceIndex(0) -2 >Emitted(39, 9) Source(39, 2) + SourceIndex(0) -3 >Emitted(39, 12) Source(39, 5) + SourceIndex(0) -4 >Emitted(39, 14) Source(39, 7) + SourceIndex(0) -5 >Emitted(39, 15) Source(39, 8) + SourceIndex(0) -6 >Emitted(39, 19) Source(39, 8) + SourceIndex(0) -7 >Emitted(39, 22) Source(39, 11) + SourceIndex(0) -8 >Emitted(39, 25) Source(39, 14) + SourceIndex(0) -9 >Emitted(39, 26) Source(39, 15) + SourceIndex(0) +1->Emitted(39, 5) Source(38, 2) + SourceIndex(0) +2 >Emitted(39, 9) Source(38, 2) + SourceIndex(0) +3 >Emitted(39, 12) Source(38, 5) + SourceIndex(0) +4 >Emitted(39, 14) Source(38, 7) + SourceIndex(0) +5 >Emitted(39, 15) Source(38, 8) + SourceIndex(0) +6 >Emitted(39, 19) Source(38, 8) + SourceIndex(0) +7 >Emitted(39, 22) Source(38, 11) + SourceIndex(0) +8 >Emitted(39, 25) Source(38, 14) + SourceIndex(0) +9 >Emitted(39, 26) Source(38, 15) + SourceIndex(0) --- >>>})(M || (M = {})); 1 > @@ -722,12 +721,12 @@ sourceFile:file.tsx > // Emit M_1.Foo > Foo, ; > } -1 >Emitted(40, 1) Source(40, 1) + SourceIndex(0) -2 >Emitted(40, 2) Source(40, 2) + SourceIndex(0) -3 >Emitted(40, 4) Source(36, 8) + SourceIndex(0) -4 >Emitted(40, 5) Source(36, 9) + SourceIndex(0) -5 >Emitted(40, 10) Source(36, 8) + SourceIndex(0) -6 >Emitted(40, 11) Source(36, 9) + SourceIndex(0) -7 >Emitted(40, 19) Source(40, 2) + SourceIndex(0) +1 >Emitted(40, 1) Source(39, 1) + SourceIndex(0) +2 >Emitted(40, 2) Source(39, 2) + SourceIndex(0) +3 >Emitted(40, 4) Source(35, 8) + SourceIndex(0) +4 >Emitted(40, 5) Source(35, 9) + SourceIndex(0) +5 >Emitted(40, 10) Source(35, 8) + SourceIndex(0) +6 >Emitted(40, 11) Source(35, 9) + SourceIndex(0) +7 >Emitted(40, 19) Source(39, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=file.jsx.map \ No newline at end of file diff --git a/tests/baselines/reference/tsxErrorRecovery1.errors.txt b/tests/baselines/reference/tsxErrorRecovery1.errors.txt index c368e48ddd1f2..d7e4f5c55dfe5 100644 --- a/tests/baselines/reference/tsxErrorRecovery1.errors.txt +++ b/tests/baselines/reference/tsxErrorRecovery1.errors.txt @@ -1,12 +1,11 @@ -tests/cases/conformance/jsx/file.tsx(5,11): error TS17008: JSX element 'div' has no corresponding closing tag. -tests/cases/conformance/jsx/file.tsx(5,19): error TS1109: Expression expected. -tests/cases/conformance/jsx/file.tsx(8,11): error TS2304: Cannot find name 'a'. -tests/cases/conformance/jsx/file.tsx(8,12): error TS1005: '}' expected. -tests/cases/conformance/jsx/file.tsx(9,1): error TS1005: ' diff --git a/tests/baselines/reference/tsxErrorRecovery2.js b/tests/baselines/reference/tsxErrorRecovery2.js index be5b6c7342431..7e60f3e53907f 100644 --- a/tests/baselines/reference/tsxErrorRecovery2.js +++ b/tests/baselines/reference/tsxErrorRecovery2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxErrorRecovery2.tsx] //// //// [file1.tsx] - declare namespace JSX { interface Element { } }
diff --git a/tests/baselines/reference/tsxErrorRecovery3.errors.txt b/tests/baselines/reference/tsxErrorRecovery3.errors.txt index 1c9e7bd8f4116..2ee6b582cd3b7 100644 --- a/tests/baselines/reference/tsxErrorRecovery3.errors.txt +++ b/tests/baselines/reference/tsxErrorRecovery3.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/jsx/file1.tsx(4,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file1.tsx(3,1): error TS2695: Left side of comma operator is unused and has no side effects. +tests/cases/conformance/jsx/file1.tsx(3,2): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file1.tsx(4,2): error TS2304: Cannot find name 'React'. -tests/cases/conformance/jsx/file1.tsx(5,2): error TS2304: Cannot find name 'React'. -tests/cases/conformance/jsx/file1.tsx(6,1): error TS2657: JSX expressions must have one parent element. +tests/cases/conformance/jsx/file1.tsx(5,1): error TS2657: JSX expressions must have one parent element. tests/cases/conformance/jsx/file2.tsx(1,9): error TS2695: Left side of comma operator is unused and has no side effects. tests/cases/conformance/jsx/file2.tsx(1,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file2.tsx(1,21): error TS2304: Cannot find name 'React'. @@ -9,7 +9,6 @@ tests/cases/conformance/jsx/file2.tsx(2,1): error TS2657: JSX expressions must h ==== tests/cases/conformance/jsx/file1.tsx (4 errors) ==== - declare namespace JSX { interface Element { } }
diff --git a/tests/baselines/reference/tsxErrorRecovery3.js b/tests/baselines/reference/tsxErrorRecovery3.js index 0e0d3d072a6ab..931a309a55e75 100644 --- a/tests/baselines/reference/tsxErrorRecovery3.js +++ b/tests/baselines/reference/tsxErrorRecovery3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxErrorRecovery3.tsx] //// //// [file1.tsx] - declare namespace JSX { interface Element { } }
diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.js b/tests/baselines/reference/tsxExternalModuleEmit1.js index c8c64062d13c1..578d952be983d 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit1.js +++ b/tests/baselines/reference/tsxExternalModuleEmit1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxExternalModuleEmit1.tsx] //// //// [react.d.ts] - declare module 'react' { class Component { } } diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.symbols b/tests/baselines/reference/tsxExternalModuleEmit1.symbols index e2d3eee98b0f3..d9a988aa168f1 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit1.symbols +++ b/tests/baselines/reference/tsxExternalModuleEmit1.symbols @@ -1,10 +1,9 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } ->Component : Symbol(Component, Decl(react.d.ts, 1, 24)) ->T : Symbol(T, Decl(react.d.ts, 2, 17)) ->U : Symbol(U, Decl(react.d.ts, 2, 19)) +>Component : Symbol(Component, Decl(react.d.ts, 0, 24)) +>T : Symbol(T, Decl(react.d.ts, 1, 17)) +>U : Symbol(U, Decl(react.d.ts, 1, 19)) } === tests/cases/conformance/jsx/app.tsx === @@ -17,9 +16,9 @@ import { Button } from './button'; export class App extends React.Component { >App : Symbol(App, Decl(app.tsx, 3, 34)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(app.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) render() { >render : Symbol(App.render, Decl(app.tsx, 5, 52)) @@ -36,9 +35,9 @@ import * as React from 'react'; export class Button extends React.Component { >Button : Symbol(Button, Decl(button.tsx, 0, 31)) ->React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) >React : Symbol(React, Decl(button.tsx, 0, 6)) ->Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>Component : Symbol(React.Component, Decl(react.d.ts, 0, 24)) render() { >render : Symbol(Button.render, Decl(button.tsx, 2, 55)) diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.types b/tests/baselines/reference/tsxExternalModuleEmit1.types index 7e28c35dd13b7..7045cd739c1d3 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit1.types +++ b/tests/baselines/reference/tsxExternalModuleEmit1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { class Component { } >Component : Component diff --git a/tests/baselines/reference/tsxExternalModuleEmit2.js b/tests/baselines/reference/tsxExternalModuleEmit2.js index aae4802145778..adf5ed2aaa633 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit2.js +++ b/tests/baselines/reference/tsxExternalModuleEmit2.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxExternalModuleEmit2.tsx] //// //// [modules.d.ts] - declare module 'mod' { var y: any; export default y; diff --git a/tests/baselines/reference/tsxExternalModuleEmit2.symbols b/tests/baselines/reference/tsxExternalModuleEmit2.symbols index 8f7cfa521361c..20ae94fb6684d 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit2.symbols +++ b/tests/baselines/reference/tsxExternalModuleEmit2.symbols @@ -1,11 +1,10 @@ === tests/cases/conformance/jsx/modules.d.ts === - declare module 'mod' { var y: any; ->y : Symbol(y, Decl(modules.d.ts, 2, 5)) +>y : Symbol(y, Decl(modules.d.ts, 1, 5)) export default y; ->y : Symbol(y, Decl(modules.d.ts, 2, 5)) +>y : Symbol(y, Decl(modules.d.ts, 1, 5)) } === tests/cases/conformance/jsx/app.tsx === diff --git a/tests/baselines/reference/tsxExternalModuleEmit2.types b/tests/baselines/reference/tsxExternalModuleEmit2.types index b4746fe46c7ce..bb858cdf0c10e 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit2.types +++ b/tests/baselines/reference/tsxExternalModuleEmit2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/modules.d.ts === - declare module 'mod' { var y: any; >y : any diff --git a/tests/baselines/reference/tsxInArrowFunction.js b/tests/baselines/reference/tsxInArrowFunction.js index ba4a0dd1d1470..e8b9ff1cc64de 100644 --- a/tests/baselines/reference/tsxInArrowFunction.js +++ b/tests/baselines/reference/tsxInArrowFunction.js @@ -1,5 +1,4 @@ //// [tsxInArrowFunction.tsx] - declare namespace JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxInArrowFunction.symbols b/tests/baselines/reference/tsxInArrowFunction.symbols index 9fc928e36e1e4..e45c428de0405 100644 --- a/tests/baselines/reference/tsxInArrowFunction.symbols +++ b/tests/baselines/reference/tsxInArrowFunction.symbols @@ -1,19 +1,18 @@ === tests/cases/conformance/jsx/tsxInArrowFunction.tsx === - declare namespace JSX { >JSX : Symbol(JSX, Decl(tsxInArrowFunction.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(tsxInArrowFunction.tsx, 1, 23)) +>Element : Symbol(Element, Decl(tsxInArrowFunction.tsx, 0, 23)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxInArrowFunction.tsx, 2, 25)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxInArrowFunction.tsx, 1, 25)) div: { ->div : Symbol(IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) text?: string; ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 3, 14)) } } } @@ -21,31 +20,31 @@ declare namespace JSX { // didn't work
{() =>
}
; ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 12, 16)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 11, 16)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) // didn't work
{x =>
}
; ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->x : Symbol(x, Decl(tsxInArrowFunction.tsx, 15, 6)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 15, 15)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>x : Symbol(x, Decl(tsxInArrowFunction.tsx, 14, 6)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 14, 15)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) // worked
{() => (
)}
; ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 18, 17)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 17, 17)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) // worked (!)
{() =>
}
; ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->text : Symbol(text, Decl(tsxInArrowFunction.tsx, 21, 16)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) ->div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 20, 16)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 2, 33)) diff --git a/tests/baselines/reference/tsxInArrowFunction.types b/tests/baselines/reference/tsxInArrowFunction.types index 76b0d1e1e6482..5134ec0e6992b 100644 --- a/tests/baselines/reference/tsxInArrowFunction.types +++ b/tests/baselines/reference/tsxInArrowFunction.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxInArrowFunction.tsx === - declare namespace JSX { >JSX : any diff --git a/tests/baselines/reference/tsxNoJsx.js b/tests/baselines/reference/tsxNoJsx.js index 37663adf2a75f..3f7ba134a506a 100644 --- a/tests/baselines/reference/tsxNoJsx.js +++ b/tests/baselines/reference/tsxNoJsx.js @@ -1,5 +1,4 @@ //// [tsxNoJsx.tsx] - ; diff --git a/tests/baselines/reference/tsxNoJsx.symbols b/tests/baselines/reference/tsxNoJsx.symbols index 4492e83cf1091..2bf187c99cd04 100644 --- a/tests/baselines/reference/tsxNoJsx.symbols +++ b/tests/baselines/reference/tsxNoJsx.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxNoJsx.tsx === - ; >nope : Symbol(unknown) diff --git a/tests/baselines/reference/tsxNoJsx.types b/tests/baselines/reference/tsxNoJsx.types index 52e6769795eb7..40a2d2609df70 100644 --- a/tests/baselines/reference/tsxNoJsx.types +++ b/tests/baselines/reference/tsxNoJsx.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/tsxNoJsx.tsx === - ; > : any >nope : any diff --git a/tests/baselines/reference/tsxPreserveEmit1.js b/tests/baselines/reference/tsxPreserveEmit1.js index 585b603abfb26..4ad18d0d7900c 100644 --- a/tests/baselines/reference/tsxPreserveEmit1.js +++ b/tests/baselines/reference/tsxPreserveEmit1.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxPreserveEmit1.tsx] //// //// [react.d.ts] - declare module 'react' { var x: any; export = x; diff --git a/tests/baselines/reference/tsxPreserveEmit1.symbols b/tests/baselines/reference/tsxPreserveEmit1.symbols index b5651d7c38e9c..d477dcc3d3c85 100644 --- a/tests/baselines/reference/tsxPreserveEmit1.symbols +++ b/tests/baselines/reference/tsxPreserveEmit1.symbols @@ -9,7 +9,7 @@ import ReactRouter = require('react-router'); import Route = ReactRouter.Route; >Route : Symbol(Route, Decl(test.tsx, 2, 45)) >ReactRouter : Symbol(ReactRouter, Decl(test.tsx, 1, 32)) ->Route : Symbol(ReactRouter.Route, Decl(react.d.ts, 7, 4)) +>Route : Symbol(ReactRouter.Route, Decl(react.d.ts, 6, 4)) var routes1 = ; >routes1 : Symbol(routes1, Decl(test.tsx, 6, 3)) @@ -32,26 +32,25 @@ module M { } === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { var x: any; ->x : Symbol(x, Decl(react.d.ts, 2, 4)) +>x : Symbol(x, Decl(react.d.ts, 1, 4)) export = x; ->x : Symbol(x, Decl(react.d.ts, 2, 4)) +>x : Symbol(x, Decl(react.d.ts, 1, 4)) } declare module ReactRouter { ->ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1)) +>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 3, 1)) var Route: any; ->Route : Symbol(Route, Decl(react.d.ts, 7, 4)) +>Route : Symbol(Route, Decl(react.d.ts, 6, 4)) interface Thing { } ->Thing : Symbol(Thing, Decl(react.d.ts, 7, 16)) +>Thing : Symbol(Thing, Decl(react.d.ts, 6, 16)) } declare module 'react-router' { export = ReactRouter; ->ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1)) +>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 3, 1)) } diff --git a/tests/baselines/reference/tsxPreserveEmit1.types b/tests/baselines/reference/tsxPreserveEmit1.types index 26da75b39e4bc..099a184b322cd 100644 --- a/tests/baselines/reference/tsxPreserveEmit1.types +++ b/tests/baselines/reference/tsxPreserveEmit1.types @@ -34,7 +34,6 @@ module M { } === tests/cases/conformance/jsx/react.d.ts === - declare module 'react' { var x: any; >x : any diff --git a/tests/baselines/reference/tsxPreserveEmit2.js b/tests/baselines/reference/tsxPreserveEmit2.js index 6a87da7b285a9..618b2894968ee 100644 --- a/tests/baselines/reference/tsxPreserveEmit2.js +++ b/tests/baselines/reference/tsxPreserveEmit2.js @@ -1,6 +1,4 @@ //// [test.tsx] - - var Route: any; var routes1 = ; diff --git a/tests/baselines/reference/tsxPreserveEmit2.symbols b/tests/baselines/reference/tsxPreserveEmit2.symbols index 4013b2e35ea8f..15b2dd694c3b5 100644 --- a/tests/baselines/reference/tsxPreserveEmit2.symbols +++ b/tests/baselines/reference/tsxPreserveEmit2.symbols @@ -1,10 +1,8 @@ === tests/cases/conformance/jsx/test.tsx === - - var Route: any; ->Route : Symbol(Route, Decl(test.tsx, 2, 3)) +>Route : Symbol(Route, Decl(test.tsx, 0, 3)) var routes1 = ; ->routes1 : Symbol(routes1, Decl(test.tsx, 3, 3)) ->Route : Symbol(Route, Decl(test.tsx, 2, 3)) +>routes1 : Symbol(routes1, Decl(test.tsx, 1, 3)) +>Route : Symbol(Route, Decl(test.tsx, 0, 3)) diff --git a/tests/baselines/reference/tsxPreserveEmit2.types b/tests/baselines/reference/tsxPreserveEmit2.types index c01f564ff53ac..9e5aac6600c08 100644 --- a/tests/baselines/reference/tsxPreserveEmit2.types +++ b/tests/baselines/reference/tsxPreserveEmit2.types @@ -1,6 +1,4 @@ === tests/cases/conformance/jsx/test.tsx === - - var Route: any; >Route : any diff --git a/tests/baselines/reference/tsxPreserveEmit3.js b/tests/baselines/reference/tsxPreserveEmit3.js index fdbe8cc2bb4b9..d886d4169b817 100644 --- a/tests/baselines/reference/tsxPreserveEmit3.js +++ b/tests/baselines/reference/tsxPreserveEmit3.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxPreserveEmit3.tsx] //// //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxPreserveEmit3.symbols b/tests/baselines/reference/tsxPreserveEmit3.symbols index ab53424104936..da163402441fc 100644 --- a/tests/baselines/reference/tsxPreserveEmit3.symbols +++ b/tests/baselines/reference/tsxPreserveEmit3.symbols @@ -1,16 +1,15 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(file.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(file.tsx, 1, 20)) +>Element : Symbol(Element, Decl(file.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 1, 22)) [s: string]: any; ->s : Symbol(s, Decl(file.tsx, 4, 3)) +>s : Symbol(s, Decl(file.tsx, 3, 3)) } } diff --git a/tests/baselines/reference/tsxPreserveEmit3.types b/tests/baselines/reference/tsxPreserveEmit3.types index 152f742a240dd..eb0a93b66f206 100644 --- a/tests/baselines/reference/tsxPreserveEmit3.types +++ b/tests/baselines/reference/tsxPreserveEmit3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxReactEmit3.js b/tests/baselines/reference/tsxReactEmit3.js index 155a316e07814..c0fcf66cc3f6c 100644 --- a/tests/baselines/reference/tsxReactEmit3.js +++ b/tests/baselines/reference/tsxReactEmit3.js @@ -1,5 +1,4 @@ //// [test.tsx] - declare module JSX { interface Element { } } declare var React: any; diff --git a/tests/baselines/reference/tsxReactEmit3.symbols b/tests/baselines/reference/tsxReactEmit3.symbols index cec45805c1e70..2220bbe888a0f 100644 --- a/tests/baselines/reference/tsxReactEmit3.symbols +++ b/tests/baselines/reference/tsxReactEmit3.symbols @@ -1,23 +1,22 @@ === tests/cases/conformance/jsx/test.tsx === - declare module JSX { interface Element { } } >JSX : Symbol(JSX, Decl(test.tsx, 0, 0)) ->Element : Symbol(Element, Decl(test.tsx, 1, 20)) +>Element : Symbol(Element, Decl(test.tsx, 0, 20)) declare var React: any; ->React : Symbol(React, Decl(test.tsx, 2, 11)) +>React : Symbol(React, Decl(test.tsx, 1, 11)) declare var Foo, Bar, baz; ->Foo : Symbol(Foo, Decl(test.tsx, 4, 11)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->baz : Symbol(baz, Decl(test.tsx, 4, 21)) +>Foo : Symbol(Foo, Decl(test.tsx, 3, 11)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>baz : Symbol(baz, Decl(test.tsx, 3, 21)) q s ; ->Foo : Symbol(Foo, Decl(test.tsx, 4, 11)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Bar : Symbol(Bar, Decl(test.tsx, 4, 16)) ->Foo : Symbol(Foo, Decl(test.tsx, 4, 11)) +>Foo : Symbol(Foo, Decl(test.tsx, 3, 11)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(test.tsx, 3, 16)) +>Foo : Symbol(Foo, Decl(test.tsx, 3, 11)) diff --git a/tests/baselines/reference/tsxReactEmit3.types b/tests/baselines/reference/tsxReactEmit3.types index 8416ec015b273..d6abc2b59d1a0 100644 --- a/tests/baselines/reference/tsxReactEmit3.types +++ b/tests/baselines/reference/tsxReactEmit3.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/test.tsx === - declare module JSX { interface Element { } } >JSX : any >Element : Element diff --git a/tests/baselines/reference/tsxReactEmit5.js b/tests/baselines/reference/tsxReactEmit5.js index a1e0c4bdf1ac8..de1e2bf30e22f 100644 --- a/tests/baselines/reference/tsxReactEmit5.js +++ b/tests/baselines/reference/tsxReactEmit5.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxReactEmit5.tsx] //// //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxReactEmit5.symbols b/tests/baselines/reference/tsxReactEmit5.symbols index 533652b0d3c5f..e80164729cf83 100644 --- a/tests/baselines/reference/tsxReactEmit5.symbols +++ b/tests/baselines/reference/tsxReactEmit5.symbols @@ -1,16 +1,15 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(file.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(file.tsx, 1, 20)) +>Element : Symbol(Element, Decl(file.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 1, 22)) [s: string]: any; ->s : Symbol(s, Decl(file.tsx, 4, 3)) +>s : Symbol(s, Decl(file.tsx, 3, 3)) } } @@ -29,7 +28,7 @@ var foo: any; var spread1 =
; >spread1 : Symbol(spread1, Decl(react-consumer.tsx, 4, 3)) ->div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) +>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22)) >x : Symbol(x, Decl(react-consumer.tsx, 4, 18)) >foo : Symbol(foo, Decl(react-consumer.tsx, 3, 3)) >y : Symbol(y, Decl(react-consumer.tsx, 4, 32)) diff --git a/tests/baselines/reference/tsxReactEmit5.types b/tests/baselines/reference/tsxReactEmit5.types index fb5e201ca3665..f6def92af5b45 100644 --- a/tests/baselines/reference/tsxReactEmit5.types +++ b/tests/baselines/reference/tsxReactEmit5.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxReactEmit6.js b/tests/baselines/reference/tsxReactEmit6.js index fb76a2e1579b3..762c231ee3059 100644 --- a/tests/baselines/reference/tsxReactEmit6.js +++ b/tests/baselines/reference/tsxReactEmit6.js @@ -1,7 +1,6 @@ //// [tests/cases/conformance/jsx/tsxReactEmit6.tsx] //// //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxReactEmit6.symbols b/tests/baselines/reference/tsxReactEmit6.symbols index eeae4493b4ff9..b360bd564ee91 100644 --- a/tests/baselines/reference/tsxReactEmit6.symbols +++ b/tests/baselines/reference/tsxReactEmit6.symbols @@ -1,16 +1,15 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : Symbol(JSX, Decl(file.tsx, 0, 0)) interface Element { } ->Element : Symbol(Element, Decl(file.tsx, 1, 20)) +>Element : Symbol(Element, Decl(file.tsx, 0, 20)) interface IntrinsicElements { ->IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 2, 22)) +>IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 1, 22)) [s: string]: any; ->s : Symbol(s, Decl(file.tsx, 4, 3)) +>s : Symbol(s, Decl(file.tsx, 3, 3)) } } @@ -32,7 +31,7 @@ namespace M { var spread1 =
; >spread1 : Symbol(spread1, Decl(react-consumer.tsx, 8, 4)) ->div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) +>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22)) >x : Symbol(x, Decl(react-consumer.tsx, 8, 19)) >foo : Symbol(foo, Decl(react-consumer.tsx, 7, 4)) >y : Symbol(y, Decl(react-consumer.tsx, 8, 33)) @@ -40,8 +39,8 @@ namespace M { // Quotes var x =
This "quote" thing
; >x : Symbol(x, Decl(react-consumer.tsx, 11, 4)) ->div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) ->div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) +>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22)) +>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22)) } diff --git a/tests/baselines/reference/tsxReactEmit6.types b/tests/baselines/reference/tsxReactEmit6.types index 7cf08b8f0f5b8..c92ad2493a60e 100644 --- a/tests/baselines/reference/tsxReactEmit6.types +++ b/tests/baselines/reference/tsxReactEmit6.types @@ -1,5 +1,4 @@ === tests/cases/conformance/jsx/file.tsx === - declare module JSX { >JSX : any diff --git a/tests/baselines/reference/tsxReactEmit7.errors.txt b/tests/baselines/reference/tsxReactEmit7.errors.txt index d151c2e349cde..0dd3130a5f494 100644 --- a/tests/baselines/reference/tsxReactEmit7.errors.txt +++ b/tests/baselines/reference/tsxReactEmit7.errors.txt @@ -1,16 +1,15 @@ +tests/cases/conformance/jsx/file.tsx(8,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(9,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(10,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(11,10): error TS2304: Cannot find name 'React'. -tests/cases/conformance/jsx/file.tsx(12,10): error TS2304: Cannot find name 'React'. +tests/cases/conformance/jsx/file.tsx(14,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(15,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(16,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(17,10): error TS2304: Cannot find name 'React'. tests/cases/conformance/jsx/file.tsx(18,10): error TS2304: Cannot find name 'React'. -tests/cases/conformance/jsx/file.tsx(19,10): error TS2304: Cannot find name 'React'. ==== tests/cases/conformance/jsx/file.tsx (9 errors) ==== - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxReactEmit7.js b/tests/baselines/reference/tsxReactEmit7.js index c119585c1f653..3597f6f09c2c2 100644 --- a/tests/baselines/reference/tsxReactEmit7.js +++ b/tests/baselines/reference/tsxReactEmit7.js @@ -1,5 +1,4 @@ //// [file.tsx] - declare module JSX { interface Element { } interface IntrinsicElements { diff --git a/tests/baselines/reference/tsxReactEmitNesting.js b/tests/baselines/reference/tsxReactEmitNesting.js index eaee315c340cb..5e1f7db39c355 100644 --- a/tests/baselines/reference/tsxReactEmitNesting.js +++ b/tests/baselines/reference/tsxReactEmitNesting.js @@ -1,5 +1,4 @@ //// [file.tsx] - declare var vdom: any; declare var ctrl: any; declare var model: any; diff --git a/tests/baselines/reference/tsxReactEmitNesting.symbols b/tests/baselines/reference/tsxReactEmitNesting.symbols index caf2425491e68..9972436ac7311 100644 --- a/tests/baselines/reference/tsxReactEmitNesting.symbols +++ b/tests/baselines/reference/tsxReactEmitNesting.symbols @@ -1,27 +1,26 @@ === tests/cases/conformance/jsx/file.tsx === - declare var vdom: any; ->vdom : Symbol(vdom, Decl(file.tsx, 1, 11)) +>vdom : Symbol(vdom, Decl(file.tsx, 0, 11)) declare var ctrl: any; ->ctrl : Symbol(ctrl, Decl(file.tsx, 2, 11)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 1, 11)) declare var model: any; ->model : Symbol(model, Decl(file.tsx, 3, 11)) +>model : Symbol(model, Decl(file.tsx, 2, 11)) // A simple render function with nesting and control statements let render = (ctrl, model) => ->render : Symbol(render, Decl(file.tsx, 6, 3)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) +>render : Symbol(render, Decl(file.tsx, 5, 3)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14)) +>model : Symbol(model, Decl(file.tsx, 5, 19))
>section : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 7, 12)) +>class : Symbol(class, Decl(file.tsx, 6, 12))
>header : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 8, 15)) +>class : Symbol(class, Decl(file.tsx, 7, 15))

todos <x>

>h1 : Symbol(unknown) @@ -29,93 +28,93 @@ let render = (ctrl, model) => >input : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 10, 18)) ->autofocus : Symbol(autofocus, Decl(file.tsx, 10, 35)) ->autocomplete : Symbol(autocomplete, Decl(file.tsx, 10, 45)) ->placeholder : Symbol(placeholder, Decl(file.tsx, 10, 64)) ->value : Symbol(value, Decl(file.tsx, 10, 101)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) ->onKeyup : Symbol(onKeyup, Decl(file.tsx, 10, 123)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) +>class : Symbol(class, Decl(file.tsx, 9, 18)) +>autofocus : Symbol(autofocus, Decl(file.tsx, 9, 35)) +>autocomplete : Symbol(autocomplete, Decl(file.tsx, 9, 45)) +>placeholder : Symbol(placeholder, Decl(file.tsx, 9, 64)) +>value : Symbol(value, Decl(file.tsx, 9, 101)) +>model : Symbol(model, Decl(file.tsx, 5, 19)) +>onKeyup : Symbol(onKeyup, Decl(file.tsx, 9, 123)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14)) +>model : Symbol(model, Decl(file.tsx, 5, 19))
>header : Symbol(unknown)
>section : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 12, 16)) ->style : Symbol(style, Decl(file.tsx, 12, 29)) ->display : Symbol(display, Decl(file.tsx, 12, 38)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) ->model : Symbol(model, Decl(file.tsx, 6, 19)) +>class : Symbol(class, Decl(file.tsx, 11, 16)) +>style : Symbol(style, Decl(file.tsx, 11, 29)) +>display : Symbol(display, Decl(file.tsx, 11, 38)) +>model : Symbol(model, Decl(file.tsx, 5, 19)) +>model : Symbol(model, Decl(file.tsx, 5, 19)) >input : Symbol(unknown) ->class : Symbol(class, Decl(file.tsx, 13, 18)) ->type : Symbol(type, Decl(file.tsx, 13, 37)) ->onChange : Symbol(onChange, Decl(file.tsx, 13, 53)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) ->ctrl : Symbol(ctrl, Decl(file.tsx, 6, 14)) +>class : Symbol(class, Decl(file.tsx, 12, 18)) +>type : Symbol(type, Decl(file.tsx, 12, 37)) +>onChange : Symbol(onChange, Decl(file.tsx, 12, 53)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14)) +>ctrl : Symbol(ctrl, Decl(file.tsx, 5, 14))